PLplot 5.15.0
Loading...
Searching...
No Matches
plplotcPYTHON_wrap.c
Go to the documentation of this file.
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (https://www.swig.org).
3 * Version 4.2.1
4 *
5 * Do not make changes to this file unless you know what you are doing - modify
6 * the SWIG interface file instead.
7 * ----------------------------------------------------------------------------- */
8
9
10#define SWIG_VERSION 0x040201
11#define SWIGPYTHON
12#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14/* -----------------------------------------------------------------------------
15 * This section contains generic SWIG labels for method/variable
16 * declarations/attributes, and other compiler dependent labels.
17 * ----------------------------------------------------------------------------- */
18
19/* template workaround for compilers that cannot correctly implement the C++ standard */
20#ifndef SWIGTEMPLATEDISAMBIGUATOR
21# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
22# define SWIGTEMPLATEDISAMBIGUATOR template
23# elif defined(__HP_aCC)
24/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
25/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
26# define SWIGTEMPLATEDISAMBIGUATOR template
27# else
28# define SWIGTEMPLATEDISAMBIGUATOR
29# endif
30#endif
31
32/* inline attribute */
33#ifndef SWIGINLINE
34# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
35# define SWIGINLINE inline
36# else
37# define SWIGINLINE
38# endif
39#endif
40
41/* attribute recognised by some compilers to avoid 'unused' warnings */
42#ifndef SWIGUNUSED
43# if defined(__GNUC__)
44# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
45# define SWIGUNUSED __attribute__ ((__unused__))
46# else
47# define SWIGUNUSED
48# endif
49# elif defined(__ICC)
50# define SWIGUNUSED __attribute__ ((__unused__))
51# else
52# define SWIGUNUSED
53# endif
54#endif
55
56#ifndef SWIG_MSC_UNSUPPRESS_4505
57# if defined(_MSC_VER)
58# pragma warning(disable : 4505) /* unreferenced local function has been removed */
59# endif
60#endif
61
62#ifndef SWIGUNUSEDPARM
63# ifdef __cplusplus
64# define SWIGUNUSEDPARM(p)
65# else
66# define SWIGUNUSEDPARM(p) p SWIGUNUSED
67# endif
68#endif
69
70/* internal SWIG method */
71#ifndef SWIGINTERN
72# define SWIGINTERN static SWIGUNUSED
73#endif
74
75/* internal inline SWIG method */
76#ifndef SWIGINTERNINLINE
77# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
78#endif
79
80/* exporting methods */
81#if defined(__GNUC__)
82# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
83# ifndef GCC_HASCLASSVISIBILITY
84# define GCC_HASCLASSVISIBILITY
85# endif
86# endif
87#endif
88
89#ifndef SWIGEXPORT
90# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
91# if defined(STATIC_LINKED)
92# define SWIGEXPORT
93# else
94# define SWIGEXPORT __declspec(dllexport)
95# endif
96# else
97# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
98# define SWIGEXPORT __attribute__ ((visibility("default")))
99# else
100# define SWIGEXPORT
101# endif
102# endif
103#endif
104
105/* calling conventions for Windows */
106#ifndef SWIGSTDCALL
107# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
108# define SWIGSTDCALL __stdcall
109# else
110# define SWIGSTDCALL
111# endif
112#endif
113
114/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
115#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
116# define _CRT_SECURE_NO_DEPRECATE
117#endif
118
119/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
120#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
121# define _SCL_SECURE_NO_DEPRECATE
122#endif
123
124/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
125#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
126# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
127#endif
128
129/* Intel's compiler complains if a variable which was never initialised is
130 * cast to void, which is a common idiom which we use to indicate that we
131 * are aware a variable isn't used. So we just silence that warning.
132 * See: https://github.com/swig/swig/issues/192 for more discussion.
133 */
134#ifdef __INTEL_COMPILER
135# pragma warning disable 592
136#endif
137
138#if defined(__cplusplus) && __cplusplus >=201103L
139# define SWIG_NULLPTR nullptr
140#else
141# define SWIG_NULLPTR NULL
142#endif
143
144/* -----------------------------------------------------------------------------
145 * swigcompat.swg
146 *
147 * Macros to provide support compatibility with older C and C++ standards.
148 * ----------------------------------------------------------------------------- */
149
150/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
151 * if you're missing it.
152 */
153#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
154 (defined __cplusplus && __cplusplus >= 201103L) || \
155 defined SWIG_HAVE_SNPRINTF) && \
156 !defined SWIG_NO_SNPRINTF
157# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
158# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
159#else
160/* Fallback versions ignore the buffer size, but most of our uses either have a
161 * fixed maximum possible size or dynamically allocate a buffer that's large
162 * enough.
163 */
164# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
165# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
166#endif
167
168
169#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
170/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
171# include <math.h>
172#endif
173
174#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
175#define PY_SSIZE_T_CLEAN
176#endif
177
178#if __GNUC__ >= 7
179#pragma GCC diagnostic push
180#if defined(__cplusplus) && __cplusplus >=201703L
181#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
182#endif
183#endif
184
185#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
186/* Use debug wrappers with the Python release dll */
187
188#if defined(_MSC_VER) && _MSC_VER >= 1929
189/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
190 * See https://github.com/swig/swig/issues/2090 */
191# include <corecrt.h>
192#endif
193
194# undef _DEBUG
195# include <Python.h>
196# define _DEBUG 1
197#else
198# include <Python.h>
199#endif
200
201#if __GNUC__ >= 7
202#pragma GCC diagnostic pop
203#endif
204
205#include <stdio.h>
206
207/* -----------------------------------------------------------------------------
208 * swigrun.swg
209 *
210 * This file contains generic C API SWIG runtime support for pointer
211 * type checking.
212 * ----------------------------------------------------------------------------- */
213
214/* This should only be incremented when either the layout of swig_type_info changes,
215 or for whatever reason, the runtime changes incompatibly */
216#define SWIG_RUNTIME_VERSION "4"
217
218/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
219#ifdef SWIG_TYPE_TABLE
220# define SWIG_QUOTE_STRING(x) #x
221# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
222# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
223#else
224# define SWIG_TYPE_TABLE_NAME
225#endif
226
227/*
228 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
229 creating a static or dynamic library from the SWIG runtime code.
230 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
231
232 But only do this if strictly necessary, ie, if you have problems
233 with your compiler or suchlike.
234*/
235
236#ifndef SWIGRUNTIME
237# define SWIGRUNTIME SWIGINTERN
238#endif
239
240#ifndef SWIGRUNTIMEINLINE
241# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
242#endif
243
244/* Generic buffer size */
245#ifndef SWIG_BUFFER_SIZE
246# define SWIG_BUFFER_SIZE 1024
247#endif
248
249/* Flags for pointer conversions */
250#define SWIG_POINTER_DISOWN 0x1
251#define SWIG_CAST_NEW_MEMORY 0x2
252#define SWIG_POINTER_NO_NULL 0x4
253#define SWIG_POINTER_CLEAR 0x8
254#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
255
256/* Flags for new pointer objects */
257#define SWIG_POINTER_OWN 0x1
258
259
260/*
261 Flags/methods for returning states.
262
263 The SWIG conversion methods, as ConvertPtr, return an integer
264 that tells if the conversion was successful or not. And if not,
265 an error code can be returned (see swigerrors.swg for the codes).
266
267 Use the following macros/flags to set or process the returning
268 states.
269
270 In old versions of SWIG, code such as the following was usually written:
271
272 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
273 // success code
274 } else {
275 //fail code
276 }
277
278 Now you can be more explicit:
279
280 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
281 if (SWIG_IsOK(res)) {
282 // success code
283 } else {
284 // fail code
285 }
286
287 which is the same really, but now you can also do
288
289 Type *ptr;
290 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
291 if (SWIG_IsOK(res)) {
292 // success code
293 if (SWIG_IsNewObj(res) {
294 ...
295 delete *ptr;
296 } else {
297 ...
298 }
299 } else {
300 // fail code
301 }
302
303 I.e., now SWIG_ConvertPtr can return new objects and you can
304 identify the case and take care of the deallocation. Of course that
305 also requires SWIG_ConvertPtr to return new result values, such as
306
307 int SWIG_ConvertPtr(obj, ptr,...) {
308 if (<obj is ok>) {
309 if (<need new object>) {
310 *ptr = <ptr to new allocated object>;
311 return SWIG_NEWOBJ;
312 } else {
313 *ptr = <ptr to old object>;
314 return SWIG_OLDOBJ;
315 }
316 } else {
317 return SWIG_BADOBJ;
318 }
319 }
320
321 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
322 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
323 SWIG errors code.
324
325 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
326 allows returning the 'cast rank', for example, if you have this
327
328 int food(double)
329 int fooi(int);
330
331 and you call
332
333 food(1) // cast rank '1' (1 -> 1.0)
334 fooi(1) // cast rank '0'
335
336 just use the SWIG_AddCast()/SWIG_CheckState()
337*/
338
339#define SWIG_OK (0)
340/* Runtime errors are < 0 */
341#define SWIG_ERROR (-1)
342/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
343/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
344/* Errors < -200 are generic runtime specific errors */
345#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
346
347#define SWIG_IsOK(r) (r >= 0)
348#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
349
350/* The CastRankLimit says how many bits are used for the cast rank */
351#define SWIG_CASTRANKLIMIT (1 << 8)
352/* The NewMask denotes the object was created (using new/malloc) */
353#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
354/* The TmpMask is for in/out typemaps that use temporary objects */
355#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
356/* Simple returning values */
357#define SWIG_BADOBJ (SWIG_ERROR)
358#define SWIG_OLDOBJ (SWIG_OK)
359#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
360#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
361/* Check, add and del object mask methods */
362#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
363#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
364#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
365#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
366#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
367#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
368
369/* Cast-Rank Mode */
370#if defined(SWIG_CASTRANK_MODE)
371# ifndef SWIG_TypeRank
372# define SWIG_TypeRank unsigned long
373# endif
374# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
375# define SWIG_MAXCASTRANK (2)
376# endif
377# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
378# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
380 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
381}
383 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
384}
385#else /* no cast-rank mode */
386# define SWIG_AddCast(r) (r)
387# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
388#endif
389
390
391#include <string.h>
392
393#ifdef __cplusplus
394extern "C" {
395#endif
396
397typedef void *(*swig_converter_func)(void *, int *);
398typedef struct swig_type_info *(*swig_dycast_func)(void **);
399
400/* Structure to store information on one type */
401typedef struct swig_type_info {
402 const char *name; /* mangled name of this type */
403 const char *str; /* human readable name of this type */
404 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
405 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
406 void *clientdata; /* language specific type data */
407 int owndata; /* flag if the structure owns the clientdata */
409
410/* Structure to store a type and conversion function used for casting */
411typedef struct swig_cast_info {
412 swig_type_info *type; /* pointer to type that is equivalent to this type */
413 swig_converter_func converter; /* function to cast the void pointers */
414 struct swig_cast_info *next; /* pointer to next cast in linked list */
415 struct swig_cast_info *prev; /* pointer to the previous cast */
417
418/* Structure used to store module information
419 * Each module generates one structure like this, and the runtime collects
420 * all of these structures and stores them in a circularly linked list.*/
421typedef struct swig_module_info {
422 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
423 size_t size; /* Number of types in this module */
424 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
425 swig_type_info **type_initial; /* Array of initially generated type structures */
426 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
427 void *clientdata; /* Language specific module data */
429
430/*
431 Compare two type names skipping the space characters, therefore
432 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
433
434 Return 0 when the two name types are equivalent, as in
435 strncmp, but skipping ' '.
436*/
437SWIGRUNTIME int
438SWIG_TypeNameComp(const char *f1, const char *l1,
439 const char *f2, const char *l2) {
440 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
441 while ((*f1 == ' ') && (f1 != l1)) ++f1;
442 while ((*f2 == ' ') && (f2 != l2)) ++f2;
443 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
444 }
445 return (int)((l1 - f1) - (l2 - f2));
446}
447
448/*
449 Check type equivalence in a name list like <name1>|<name2>|...
450 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
451*/
452SWIGRUNTIME int
453SWIG_TypeCmp(const char *nb, const char *tb) {
454 int equiv = 1;
455 const char* te = tb + strlen(tb);
456 const char* ne = nb;
457 while (equiv != 0 && *ne) {
458 for (nb = ne; *ne; ++ne) {
459 if (*ne == '|') break;
460 }
461 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
462 if (*ne) ++ne;
463 }
464 return equiv;
465}
466
467/*
468 Check type equivalence in a name list like <name1>|<name2>|...
469 Return 0 if not equal, 1 if equal
470*/
471SWIGRUNTIME int
472SWIG_TypeEquiv(const char *nb, const char *tb) {
473 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
474}
475
476/*
477 Check the typename
478*/
480SWIG_TypeCheck(const char *c, swig_type_info *ty) {
481 if (ty) {
482 swig_cast_info *iter = ty->cast;
483 while (iter) {
484 if (strcmp(iter->type->name, c) == 0) {
485 if (iter == ty->cast)
486 return iter;
487 /* Move iter to the top of the linked list */
488 iter->prev->next = iter->next;
489 if (iter->next)
490 iter->next->prev = iter->prev;
491 iter->next = ty->cast;
492 iter->prev = 0;
493 if (ty->cast) ty->cast->prev = iter;
494 ty->cast = iter;
495 return iter;
496 }
497 iter = iter->next;
498 }
499 }
500 return 0;
501}
502
503/*
504 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
505*/
508 if (ty) {
509 swig_cast_info *iter = ty->cast;
510 while (iter) {
511 if (iter->type == from) {
512 if (iter == ty->cast)
513 return iter;
514 /* Move iter to the top of the linked list */
515 iter->prev->next = iter->next;
516 if (iter->next)
517 iter->next->prev = iter->prev;
518 iter->next = ty->cast;
519 iter->prev = 0;
520 if (ty->cast) ty->cast->prev = iter;
521 ty->cast = iter;
522 return iter;
523 }
524 iter = iter->next;
525 }
526 }
527 return 0;
528}
529
530/*
531 Cast a pointer up an inheritance hierarchy
532*/
534SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
535 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
536}
537
538/*
539 Dynamic pointer casting. Down an inheritance hierarchy
540*/
543 swig_type_info *lastty = ty;
544 if (!ty || !ty->dcast) return ty;
545 while (ty && (ty->dcast)) {
546 ty = (*ty->dcast)(ptr);
547 if (ty) lastty = ty;
548 }
549 return lastty;
550}
551
552/*
553 Return the name associated with this type
554*/
555SWIGRUNTIMEINLINE const char *
557 return ty->name;
558}
559
560/*
561 Return the pretty name associated with this type,
562 that is an unmangled type name in a form presentable to the user.
563*/
564SWIGRUNTIME const char *
566 /* The "str" field contains the equivalent pretty names of the
567 type, separated by vertical-bar characters. Choose the last
568 name. It should be the most specific; a fully resolved name
569 but not necessarily with default template parameters expanded. */
570 if (!type) return NULL;
571 if (type->str != NULL) {
572 const char *last_name = type->str;
573 const char *s;
574 for (s = type->str; *s; s++)
575 if (*s == '|') last_name = s+1;
576 return last_name;
577 }
578 else
579 return type->name;
580}
581
582/*
583 Set the clientdata field for a type
584*/
585SWIGRUNTIME void
587 swig_cast_info *cast = ti->cast;
588 /* if (ti->clientdata == clientdata) return; */
590
591 while (cast) {
592 if (!cast->converter) {
593 swig_type_info *tc = cast->type;
594 if (!tc->clientdata) {
596 }
597 }
598 cast = cast->next;
599 }
600}
601SWIGRUNTIME void
606
607/*
608 Search for a swig_type_info structure only by mangled name
609 Search is a O(log #types)
610
611 We start searching at module start, and finish searching when start == end.
612 Note: if start == end at the beginning of the function, we go all the way around
613 the circular list.
614*/
617 swig_module_info *end,
618 const char *name) {
619 swig_module_info *iter = start;
620 do {
621 if (iter->size) {
622 size_t l = 0;
623 size_t r = iter->size - 1;
624 do {
625 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
626 size_t i = (l + r) >> 1;
627 const char *iname = iter->types[i]->name;
628 if (iname) {
629 int compare = strcmp(name, iname);
630 if (compare == 0) {
631 return iter->types[i];
632 } else if (compare < 0) {
633 if (i) {
634 r = i - 1;
635 } else {
636 break;
637 }
638 } else if (compare > 0) {
639 l = i + 1;
640 }
641 } else {
642 break; /* should never happen */
643 }
644 } while (l <= r);
645 }
646 iter = iter->next;
647 } while (iter != end);
648 return 0;
649}
650
651/*
652 Search for a swig_type_info structure for either a mangled name or a human readable name.
653 It first searches the mangled names of the types, which is a O(log #types)
654 If a type is not found it then searches the human readable names, which is O(#types).
655
656 We start searching at module start, and finish searching when start == end.
657 Note: if start == end at the beginning of the function, we go all the way around
658 the circular list.
659*/
662 swig_module_info *end,
663 const char *name) {
664 /* STEP 1: Search the name field using binary search */
666 if (ret) {
667 return ret;
668 } else {
669 /* STEP 2: If the type hasn't been found, do a complete search
670 of the str field (the human readable name) */
671 swig_module_info *iter = start;
672 do {
673 size_t i = 0;
674 for (; i < iter->size; ++i) {
675 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
676 return iter->types[i];
677 }
678 iter = iter->next;
679 } while (iter != end);
680 }
681
682 /* neither found a match */
683 return 0;
684}
685
686/*
687 Pack binary data into a string
688*/
689SWIGRUNTIME char *
690SWIG_PackData(char *c, void *ptr, size_t sz) {
691 static const char hex[17] = "0123456789abcdef";
692 const unsigned char *u = (unsigned char *) ptr;
693 const unsigned char *eu = u + sz;
694 for (; u != eu; ++u) {
695 unsigned char uu = *u;
696 *(c++) = hex[(uu & 0xf0) >> 4];
697 *(c++) = hex[uu & 0xf];
698 }
699 return c;
700}
701
702/*
703 Unpack binary data from a string
704*/
705SWIGRUNTIME const char *
706SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
707 unsigned char *u = (unsigned char *) ptr;
708 const unsigned char *eu = u + sz;
709 for (; u != eu; ++u) {
710 char d = *(c++);
711 unsigned char uu;
712 if ((d >= '0') && (d <= '9'))
713 uu = (unsigned char)((d - '0') << 4);
714 else if ((d >= 'a') && (d <= 'f'))
715 uu = (unsigned char)((d - ('a'-10)) << 4);
716 else
717 return (char *) 0;
718 d = *(c++);
719 if ((d >= '0') && (d <= '9'))
720 uu |= (unsigned char)(d - '0');
721 else if ((d >= 'a') && (d <= 'f'))
722 uu |= (unsigned char)(d - ('a'-10));
723 else
724 return (char *) 0;
725 *u = uu;
726 }
727 return c;
728}
729
730/*
731 Pack 'void *' into a string buffer.
732*/
733SWIGRUNTIME char *
734SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
735 char *r = buff;
736 if ((2*sizeof(void *) + 2) > bsz) return 0;
737 *(r++) = '_';
738 r = SWIG_PackData(r,&ptr,sizeof(void *));
739 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
740 strcpy(r,name);
741 return buff;
742}
743
744SWIGRUNTIME const char *
745SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
746 if (*c != '_') {
747 if (strcmp(c,"NULL") == 0) {
748 *ptr = (void *) 0;
749 return name;
750 } else {
751 return 0;
752 }
753 }
754 return SWIG_UnpackData(++c,ptr,sizeof(void *));
755}
756
757SWIGRUNTIME char *
758SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
759 char *r = buff;
760 size_t lname = (name ? strlen(name) : 0);
761 if ((2*sz + 2 + lname) > bsz) return 0;
762 *(r++) = '_';
763 r = SWIG_PackData(r,ptr,sz);
764 if (lname) {
765 strncpy(r,name,lname+1);
766 } else {
767 *r = 0;
768 }
769 return buff;
770}
771
772SWIGRUNTIME const char *
773SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
774 if (*c != '_') {
775 if (strcmp(c,"NULL") == 0) {
776 memset(ptr,0,sz);
777 return name;
778 } else {
779 return 0;
780 }
781 }
782 return SWIG_UnpackData(++c,ptr,sz);
783}
784
785#ifdef __cplusplus
786}
787#endif
788
789/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
790#define SWIG_UnknownError -1
791#define SWIG_IOError -2
792#define SWIG_RuntimeError -3
793#define SWIG_IndexError -4
794#define SWIG_TypeError -5
795#define SWIG_DivisionByZero -6
796#define SWIG_OverflowError -7
797#define SWIG_SyntaxError -8
798#define SWIG_ValueError -9
799#define SWIG_SystemError -10
800#define SWIG_AttributeError -11
801#define SWIG_MemoryError -12
802#define SWIG_NullReferenceError -13
803
804
805/* Compatibility macros for Python 3 */
806#if PY_VERSION_HEX >= 0x03000000
807
808#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
809#define PyInt_Check(x) PyLong_Check(x)
810#define PyInt_AsLong(x) PyLong_AsLong(x)
811#define PyInt_FromLong(x) PyLong_FromLong(x)
812#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
813#define PyString_Check(name) PyBytes_Check(name)
814#define PyString_FromString(x) PyUnicode_FromString(x)
815#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
816#define PyString_AsString(str) PyBytes_AsString(str)
817#define PyString_Size(str) PyBytes_Size(str)
818#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
819#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
820#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
821
822#endif
823
824#ifndef Py_TYPE
825# define Py_TYPE(op) ((op)->ob_type)
826#endif
827
828/* SWIG APIs for compatibility of both Python 2 & 3 */
829
830#if PY_VERSION_HEX >= 0x03000000
831# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
832#else
833# define SWIG_Python_str_FromFormat PyString_FromFormat
834#endif
835
836
837/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */
838SWIGINTERN const char *
839SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
840{
841#if PY_VERSION_HEX >= 0x03030000
842# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
843 *pbytes = NULL;
844 return PyUnicode_AsUTF8AndSize(str, psize);
845# else
846 *pbytes = PyUnicode_AsUTF8String(str);
847 const char *chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL;
848 if (chars && psize)
849 *psize = PyBytes_Size(*pbytes);
850 return chars;
851# endif
852#else
853 char *chars = NULL;
854 *pbytes = NULL;
855 PyString_AsStringAndSize(str, &chars, psize);
856 return chars;
857#endif
858}
859
860SWIGINTERN PyObject*
862{
863#if PY_VERSION_HEX >= 0x03000000
864 return PyUnicode_FromString(c);
865#else
866 return PyString_FromString(c);
867#endif
868}
869
870#ifndef PyObject_DEL
871# define PyObject_DEL PyObject_Del
872#endif
873
874/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
875# define SWIGPY_USE_CAPSULE
876#ifdef SWIGPYTHON_BUILTIN
877# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
878#else
879# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
880#endif
881# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
882
883#if PY_VERSION_HEX < 0x03020000
884#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
885#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
886#define Py_hash_t long
887#endif
888
889#ifdef Py_LIMITED_API
890# define PyTuple_GET_ITEM PyTuple_GetItem
891/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used
892 interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */
893# define PyTuple_SET_ITEM PyTuple_SetItem
894# define PyTuple_GET_SIZE PyTuple_Size
895# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
896# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
897# define PyCFunction_GET_SELF PyCFunction_GetSelf
898# define PyList_GET_ITEM PyList_GetItem
899# define PyList_SET_ITEM PyList_SetItem
900# define PySliceObject PyObject
901#endif
902
903/* -----------------------------------------------------------------------------
904 * error manipulation
905 * ----------------------------------------------------------------------------- */
906
907SWIGRUNTIME PyObject*
909 PyObject* type = 0;
910 switch(code) {
911 case SWIG_MemoryError:
912 type = PyExc_MemoryError;
913 break;
914 case SWIG_IOError:
915 type = PyExc_IOError;
916 break;
918 type = PyExc_RuntimeError;
919 break;
920 case SWIG_IndexError:
921 type = PyExc_IndexError;
922 break;
923 case SWIG_TypeError:
924 type = PyExc_TypeError;
925 break;
927 type = PyExc_ZeroDivisionError;
928 break;
930 type = PyExc_OverflowError;
931 break;
932 case SWIG_SyntaxError:
933 type = PyExc_SyntaxError;
934 break;
935 case SWIG_ValueError:
936 type = PyExc_ValueError;
937 break;
938 case SWIG_SystemError:
939 type = PyExc_SystemError;
940 break;
942 type = PyExc_AttributeError;
943 break;
944 default:
945 type = PyExc_RuntimeError;
946 }
947 return type;
948}
949
950
951SWIGRUNTIME void
952SWIG_Python_AddErrorMsg(const char* mesg)
953{
954 PyObject *type = 0;
955 PyObject *value = 0;
956 PyObject *traceback = 0;
957
958 if (PyErr_Occurred())
959 PyErr_Fetch(&type, &value, &traceback);
960 if (value) {
961 PyObject *old_str = PyObject_Str(value);
962 PyObject *bytes = NULL;
963 const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
964 PyErr_Clear();
965 Py_XINCREF(type);
966 if (tmp)
967 PyErr_Format(type, "%s %s", tmp, mesg);
968 else
969 PyErr_Format(type, "%s", mesg);
970 Py_XDECREF(bytes);
971 Py_DECREF(old_str);
972 Py_DECREF(value);
973 } else {
974 PyErr_SetString(PyExc_RuntimeError, mesg);
975 }
976}
977
978SWIGRUNTIME int
980{
981 PyObject *error;
982 if (obj)
983 return 0;
984 error = PyErr_Occurred();
985 return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
986}
987
988SWIGRUNTIME void
990{
992 /* Use existing TypeError to preserve stacktrace and enhance with given message */
993 PyObject *newvalue;
994 PyObject *type = NULL, *value = NULL, *traceback = NULL;
995 PyErr_Fetch(&type, &value, &traceback);
996#if PY_VERSION_HEX >= 0x03000000
997 newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
998#else
999 newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
1000#endif
1001 if (newvalue) {
1002 Py_XDECREF(value);
1003 PyErr_Restore(type, newvalue, traceback);
1004 } else {
1005 PyErr_Restore(type, value, traceback);
1006 }
1007 } else {
1008 /* Raise TypeError using given message */
1009 PyErr_SetString(PyExc_TypeError, message);
1010 }
1011}
1012
1013#if defined(SWIG_PYTHON_NO_THREADS)
1014# if defined(SWIG_PYTHON_THREADS)
1015# undef SWIG_PYTHON_THREADS
1016# endif
1017#endif
1018#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1019# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1020# define SWIG_PYTHON_USE_GIL
1021# endif
1022# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1023# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1024# if PY_VERSION_HEX < 0x03070000
1025# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1026# else
1027# define SWIG_PYTHON_INITIALIZE_THREADS
1028# endif
1029# endif
1030# ifdef __cplusplus /* C++ code */
1031 class SWIG_Python_Thread_Block {
1032 bool status;
1033 PyGILState_STATE state;
1034 public:
1035 void end() { if (status) { PyGILState_Release(state); status = false;} }
1036 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1037 ~SWIG_Python_Thread_Block() { end(); }
1038 };
1039 class SWIG_Python_Thread_Allow {
1040 bool status;
1041 PyThreadState *save;
1042 public:
1043 void end() { if (status) { status = false; PyEval_RestoreThread(save); }}
1044 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1045 ~SWIG_Python_Thread_Allow() { end(); }
1046 };
1047# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1048# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1049# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1050# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1051# else /* C code */
1052# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1053# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1054# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1055# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1056# endif
1057# else /* Old thread way, not implemented, user must provide it */
1058# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1059# define SWIG_PYTHON_INITIALIZE_THREADS
1060# endif
1061# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1062# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1063# endif
1064# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1065# define SWIG_PYTHON_THREAD_END_BLOCK
1066# endif
1067# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1068# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1069# endif
1070# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1071# define SWIG_PYTHON_THREAD_END_ALLOW
1072# endif
1073# endif
1074#else /* No thread support */
1075# define SWIG_PYTHON_INITIALIZE_THREADS
1076# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1077# define SWIG_PYTHON_THREAD_END_BLOCK
1078# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1079# define SWIG_PYTHON_THREAD_END_ALLOW
1080#endif
1081
1082/* -----------------------------------------------------------------------------
1083 * Python API portion that goes into the runtime
1084 * ----------------------------------------------------------------------------- */
1085
1086#ifdef __cplusplus
1087extern "C" {
1088#endif
1089
1090/* -----------------------------------------------------------------------------
1091 * Constant declarations
1092 * ----------------------------------------------------------------------------- */
1093
1094/* Constant Types */
1095#define SWIG_PY_POINTER 4
1096#define SWIG_PY_BINARY 5
1097
1098/* Constant information structure */
1107
1108#ifdef __cplusplus
1109}
1110#endif
1111
1112
1113/* -----------------------------------------------------------------------------
1114 * pyrun.swg
1115 *
1116 * This file contains the runtime support for Python modules
1117 * and includes code for managing global variables and pointer
1118 * type checking.
1119 *
1120 * ----------------------------------------------------------------------------- */
1121
1122#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
1123# error "This version of SWIG only supports Python >= 2.7"
1124#endif
1125
1126#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
1127# error "This version of SWIG only supports Python 3 >= 3.3"
1128#endif
1129
1130/* Common SWIG API */
1131
1132/* for raw pointers */
1133#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1134#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1135#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1136
1137#ifdef SWIGPYTHON_BUILTIN
1138#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1139#else
1140#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1141#endif
1142
1143#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1144
1145#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1146#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1147#define swig_owntype int
1148
1149/* for raw packed data */
1150#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1151#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1152
1153/* for class or struct pointers */
1154#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1155#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1156
1157/* for C or C++ function pointers */
1158#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1159#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1160
1161/* for C++ member pointers, ie, member methods */
1162#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1163#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1164
1165
1166/* Runtime API */
1167
1168#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1169#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1170#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1171
1172#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1173#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1174#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1175#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1176#define SWIG_fail goto fail
1177
1178
1179/* Runtime API implementation */
1180
1181/* Error manipulation */
1182
1183SWIGINTERN void
1184SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1186 PyErr_SetObject(errtype, obj);
1187 Py_DECREF(obj);
1189}
1190
1191SWIGINTERN void
1192SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1194 PyErr_SetString(errtype, msg);
1196}
1197
1198#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1199
1200/* Set a constant value */
1201
1202#if defined(SWIGPYTHON_BUILTIN)
1203
1204SWIGINTERN void
1205SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1206 PyObject *s = PyString_InternFromString(key);
1207 PyList_Append(seq, s);
1208 Py_DECREF(s);
1209}
1210
1211SWIGINTERN void
1212SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1213 PyDict_SetItemString(d, name, obj);
1214 Py_DECREF(obj);
1215 if (public_interface)
1216 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1217}
1218
1219#else
1220
1221SWIGINTERN void
1222SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1223 PyDict_SetItemString(d, name, obj);
1224 Py_DECREF(obj);
1225}
1226
1227#endif
1228
1229/* Append a value to the result obj */
1230
1231SWIGINTERN PyObject*
1232SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1233 if (!result) {
1234 result = obj;
1235 } else if (result == Py_None) {
1236 Py_DECREF(result);
1237 result = obj;
1238 } else {
1239 if (!PyList_Check(result)) {
1240 PyObject *o2 = result;
1241 result = PyList_New(1);
1242 if (result) {
1243 PyList_SET_ITEM(result, 0, o2);
1244 } else {
1245 Py_DECREF(obj);
1246 return o2;
1247 }
1248 }
1249 PyList_Append(result,obj);
1250 Py_DECREF(obj);
1251 }
1252 return result;
1253}
1254
1255/* Unpack the argument tuple */
1256
1257SWIGINTERN Py_ssize_t
1258SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1259{
1260 if (!args) {
1261 if (!min && !max) {
1262 return 1;
1263 } else {
1264 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1265 name, (min == max ? "" : "at least "), (int)min);
1266 return 0;
1267 }
1268 }
1269 if (!PyTuple_Check(args)) {
1270 if (min <= 1 && max >= 1) {
1271 Py_ssize_t i;
1272 objs[0] = args;
1273 for (i = 1; i < max; ++i) {
1274 objs[i] = 0;
1275 }
1276 return 2;
1277 }
1278 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1279 return 0;
1280 } else {
1281 Py_ssize_t l = PyTuple_GET_SIZE(args);
1282 if (l < min) {
1283 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1284 name, (min == max ? "" : "at least "), (int)min, (int)l);
1285 return 0;
1286 } else if (l > max) {
1287 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1288 name, (min == max ? "" : "at most "), (int)max, (int)l);
1289 return 0;
1290 } else {
1291 Py_ssize_t i;
1292 for (i = 0; i < l; ++i) {
1293 objs[i] = PyTuple_GET_ITEM(args, i);
1294 }
1295 for (; l < max; ++l) {
1296 objs[l] = 0;
1297 }
1298 return i + 1;
1299 }
1300 }
1301}
1302
1303SWIGINTERN int
1304SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
1305 int no_kwargs = 1;
1306 if (kwargs) {
1307 assert(PyDict_Check(kwargs));
1308 if (PyDict_Size(kwargs) > 0) {
1309 PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
1310 no_kwargs = 0;
1311 }
1312 }
1313 return no_kwargs;
1314}
1315
1316/* A functor is a function object with one single object argument */
1317#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1318
1319/*
1320 Helper for static pointer initialization for both C and C++ code, for example
1321 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1322*/
1323#ifdef __cplusplus
1324#define SWIG_STATIC_POINTER(var) var
1325#else
1326#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1327#endif
1328
1329#ifdef __cplusplus
1330extern "C" {
1331#endif
1332
1333/* Python-specific SWIG API */
1334#define SWIG_newvarlink() SWIG_Python_newvarlink()
1335#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
1336#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
1337
1338/* -----------------------------------------------------------------------------
1339 * global variable support code.
1340 * ----------------------------------------------------------------------------- */
1341
1342typedef struct swig_globalvar {
1343 char *name; /* Name of global variable */
1344 PyObject *(*get_attr)(void); /* Return the current value */
1345 int (*set_attr)(PyObject *); /* Set the value */
1348
1353
1354SWIGINTERN PyObject *
1356#if PY_VERSION_HEX >= 0x03000000
1357 return PyUnicode_InternFromString("<Swig global variables>");
1358#else
1359 return PyString_FromString("<Swig global variables>");
1360#endif
1361}
1362
1363SWIGINTERN PyObject *
1364swig_varlink_str(PyObject *o) {
1366#if PY_VERSION_HEX >= 0x03000000
1367 PyObject *str = PyUnicode_InternFromString("(");
1368 PyObject *tail;
1369 PyObject *joined;
1370 swig_globalvar *var;
1371 for (var = v->vars; var; var=var->next) {
1372 tail = PyUnicode_FromString(var->name);
1373 joined = PyUnicode_Concat(str, tail);
1374 Py_DecRef(str);
1375 Py_DecRef(tail);
1376 str = joined;
1377 if (var->next) {
1378 tail = PyUnicode_InternFromString(", ");
1379 joined = PyUnicode_Concat(str, tail);
1380 Py_DecRef(str);
1381 Py_DecRef(tail);
1382 str = joined;
1383 }
1384 }
1385 tail = PyUnicode_InternFromString(")");
1386 joined = PyUnicode_Concat(str, tail);
1387 Py_DecRef(str);
1388 Py_DecRef(tail);
1389 str = joined;
1390#else
1391 PyObject *str = PyString_FromString("(");
1392 swig_globalvar *var;
1393 for (var = v->vars; var; var=var->next) {
1394 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
1395 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
1396 }
1397 PyString_ConcatAndDel(&str,PyString_FromString(")"));
1398#endif
1399 return str;
1400}
1401
1402SWIGINTERN void
1405 swig_globalvar *var = v->vars;
1406 while (var) {
1407 swig_globalvar *n = var->next;
1408 free(var->name);
1409 free(var);
1410 var = n;
1411 }
1412}
1413
1414SWIGINTERN PyObject *
1415swig_varlink_getattr(PyObject *o, char *n) {
1417 PyObject *res = NULL;
1418 swig_globalvar *var = v->vars;
1419 while (var) {
1420 if (strcmp(var->name,n) == 0) {
1421 res = (*var->get_attr)();
1422 break;
1423 }
1424 var = var->next;
1425 }
1426 if (res == NULL && !PyErr_Occurred()) {
1427 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
1428 }
1429 return res;
1430}
1431
1432SWIGINTERN int
1433swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
1435 int res = 1;
1436 swig_globalvar *var = v->vars;
1437 while (var) {
1438 if (strcmp(var->name,n) == 0) {
1439 res = (*var->set_attr)(p);
1440 break;
1441 }
1442 var = var->next;
1443 }
1444 if (res == 1 && !PyErr_Occurred()) {
1445 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
1446 }
1447 return res;
1448}
1449
1450SWIGINTERN PyTypeObject*
1452 static char varlink__doc__[] = "Swig var link object";
1453#ifndef Py_LIMITED_API
1454 static PyTypeObject varlink_type;
1455 static int type_init = 0;
1456 if (!type_init) {
1457 const PyTypeObject tmp = {
1458#if PY_VERSION_HEX >= 0x03000000
1459 PyVarObject_HEAD_INIT(NULL, 0)
1460#else
1461 PyObject_HEAD_INIT(NULL)
1462 0, /* ob_size */
1463#endif
1464 "swigvarlink", /* tp_name */
1465 sizeof(swig_varlinkobject), /* tp_basicsize */
1466 0, /* tp_itemsize */
1467 (destructor) swig_varlink_dealloc, /* tp_dealloc */
1468#if PY_VERSION_HEX < 0x030800b4
1469 (printfunc)0, /*tp_print*/
1470#else
1471 (Py_ssize_t)0, /*tp_vectorcall_offset*/
1472#endif
1473 (getattrfunc) swig_varlink_getattr, /* tp_getattr */
1474 (setattrfunc) swig_varlink_setattr, /* tp_setattr */
1475 0, /* tp_compare */
1476 (reprfunc) swig_varlink_repr, /* tp_repr */
1477 0, /* tp_as_number */
1478 0, /* tp_as_sequence */
1479 0, /* tp_as_mapping */
1480 0, /* tp_hash */
1481 0, /* tp_call */
1482 (reprfunc) swig_varlink_str, /* tp_str */
1483 0, /* tp_getattro */
1484 0, /* tp_setattro */
1485 0, /* tp_as_buffer */
1486 0, /* tp_flags */
1487 varlink__doc__, /* tp_doc */
1488 0, /* tp_traverse */
1489 0, /* tp_clear */
1490 0, /* tp_richcompare */
1491 0, /* tp_weaklistoffset */
1492 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
1493 0, /* tp_del */
1494 0, /* tp_version_tag */
1495#if PY_VERSION_HEX >= 0x03040000
1496 0, /* tp_finalize */
1497#endif
1498#if PY_VERSION_HEX >= 0x03080000
1499 0, /* tp_vectorcall */
1500#endif
1501#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
1502 0, /* tp_print */
1503#endif
1504#if PY_VERSION_HEX >= 0x030C0000
1505 0, /* tp_watched */
1506#endif
1507#ifdef COUNT_ALLOCS
1508 0, /* tp_allocs */
1509 0, /* tp_frees */
1510 0, /* tp_maxalloc */
1511 0, /* tp_prev */
1512 0 /* tp_next */
1513#endif
1514 };
1515 varlink_type = tmp;
1516 type_init = 1;
1517 if (PyType_Ready(&varlink_type) < 0)
1518 return NULL;
1519 }
1520 return &varlink_type;
1521#else
1522 PyType_Slot slots[] = {
1523 { Py_tp_dealloc, (void *)swig_varlink_dealloc },
1524 { Py_tp_repr, (void *)swig_varlink_repr },
1525 { Py_tp_getattr, (void *)swig_varlink_getattr },
1526 { Py_tp_setattr, (void *)swig_varlink_setattr },
1527 { Py_tp_str, (void *)swig_varlink_str },
1528 { Py_tp_doc, (void *)varlink__doc__ },
1529 { 0, NULL }
1530 };
1531 PyType_Spec spec = {
1532 "swigvarlink",
1533 sizeof(swig_varlinkobject),
1534 0,
1535 Py_TPFLAGS_DEFAULT,
1536 slots
1537 };
1538 return (PyTypeObject *)PyType_FromSpec(&spec);
1539#endif
1540}
1541
1542/* Create a variable linking object for use later */
1543SWIGINTERN PyObject *
1545 swig_varlinkobject *result = PyObject_New(swig_varlinkobject, swig_varlink_type());
1546 if (result) {
1547 result->vars = 0;
1548 }
1549 return ((PyObject*) result);
1550}
1551
1552SWIGINTERN void
1553SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
1555 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
1556 if (gv) {
1557 size_t size = strlen(name)+1;
1558 gv->name = (char *)malloc(size);
1559 if (gv->name) {
1560 memcpy(gv->name, name, size);
1561 gv->get_attr = get_attr;
1562 gv->set_attr = set_attr;
1563 gv->next = v->vars;
1564 }
1565 }
1566 v->vars = gv;
1567}
1568
1569
1570static PyObject *Swig_Globals_global = NULL;
1571
1572SWIGINTERN PyObject *
1574 if (Swig_Globals_global == NULL) {
1576 }
1577 return Swig_Globals_global;
1578}
1579
1580#ifdef __cplusplus
1581}
1582#endif
1583
1584/* -----------------------------------------------------------------------------
1585 * Pointer declarations
1586 * ----------------------------------------------------------------------------- */
1587
1588/* Flags for new pointer objects */
1589#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1590#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1591
1592#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1593
1594#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1595#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1596
1597#ifdef __cplusplus
1598extern "C" {
1599#endif
1600
1601/* The python void return value */
1602
1603SWIGRUNTIMEINLINE PyObject *
1605{
1606 PyObject *none = Py_None;
1607 Py_INCREF(none);
1608 return none;
1609}
1610
1611/* SwigPyClientData */
1612
1613typedef struct {
1614 PyObject *klass;
1615 PyObject *newraw;
1616 PyObject *newargs;
1617 PyObject *destroy;
1620 PyTypeObject *pytype;
1622
1625{
1627 int fail = data ? data->implicitconv : 0;
1628 if (fail)
1629 PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
1630 return fail;
1631}
1632
1633SWIGRUNTIMEINLINE PyObject *
1635 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1636 PyObject *klass = data ? data->klass : 0;
1637 return (klass ? klass : PyExc_RuntimeError);
1638}
1639
1640
1643{
1644 if (!obj) {
1645 return 0;
1646 } else {
1647 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1648 /* the klass element */
1649 data->klass = obj;
1650 Py_INCREF(data->klass);
1651 /* the newraw method and newargs arguments used to create a new raw instance */
1652 if (PyClass_Check(obj)) {
1653 data->newraw = 0;
1654 Py_INCREF(obj);
1655 data->newargs = obj;
1656 } else {
1657 data->newraw = PyObject_GetAttrString(data->klass, "__new__");
1658 if (data->newraw) {
1659 data->newargs = PyTuple_New(1);
1660 if (data->newargs) {
1661 Py_INCREF(obj);
1662 PyTuple_SET_ITEM(data->newargs, 0, obj);
1663 } else {
1664 Py_DECREF(data->newraw);
1665 Py_DECREF(data->klass);
1666 free(data);
1667 return 0;
1668 }
1669 } else {
1670 Py_INCREF(obj);
1671 data->newargs = obj;
1672 }
1673 }
1674 /* the destroy method, aka as the C++ delete method */
1675 data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1676 if (PyErr_Occurred()) {
1677 PyErr_Clear();
1678 data->destroy = 0;
1679 }
1680 if (data->destroy) {
1681 data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
1682 } else {
1683 data->delargs = 0;
1684 }
1685 data->implicitconv = 0;
1686 data->pytype = 0;
1687 return data;
1688 }
1689}
1690
1691SWIGRUNTIME void
1693{
1694 Py_XDECREF(data->klass);
1695 Py_XDECREF(data->newraw);
1696 Py_XDECREF(data->newargs);
1697 Py_XDECREF(data->destroy);
1698 free(data);
1699}
1700
1701/* =============== SwigPyObject =====================*/
1702
1703typedef struct {
1704 PyObject_HEAD
1705 void *ptr;
1707 int own;
1708 PyObject *next;
1709#ifdef SWIGPYTHON_BUILTIN
1710 PyObject *dict;
1711#endif
1712} SwigPyObject;
1713
1714
1715#ifdef SWIGPYTHON_BUILTIN
1716
1717SWIGRUNTIME PyObject *
1718SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1719{
1720 SwigPyObject *sobj = (SwigPyObject *)v;
1721
1722 if (!sobj->dict)
1723 sobj->dict = PyDict_New();
1724
1725 Py_XINCREF(sobj->dict);
1726 return sobj->dict;
1727}
1728
1729#endif
1730
1731SWIGRUNTIME PyObject *
1733{
1734 return PyLong_FromVoidPtr(v->ptr);
1735}
1736
1737SWIGRUNTIME PyObject *
1739{
1740 PyObject *res = NULL;
1741 PyObject *args = PyTuple_New(1);
1742 if (args) {
1743 PyObject *val = SwigPyObject_long(v);
1744 if (val) {
1745 PyObject *ofmt;
1746 PyTuple_SET_ITEM(args, 0, val);
1747 ofmt = SWIG_Python_str_FromChar(fmt);
1748 if (ofmt) {
1749#if PY_VERSION_HEX >= 0x03000000
1750 res = PyUnicode_Format(ofmt,args);
1751#else
1752 res = PyString_Format(ofmt,args);
1753#endif
1754 Py_DECREF(ofmt);
1755 }
1756 }
1757 Py_DECREF(args);
1758 }
1759 return res;
1760}
1761
1762SWIGRUNTIME PyObject *
1764{
1765 return SwigPyObject_format("%o",v);
1766}
1767
1768SWIGRUNTIME PyObject *
1770{
1771 return SwigPyObject_format("%x",v);
1772}
1773
1774SWIGRUNTIME PyObject *
1776{
1777 const char *name = SWIG_TypePrettyName(v->ty);
1778 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1779 if (repr && v->next) {
1780 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1781 if (nrep) {
1782# if PY_VERSION_HEX >= 0x03000000
1783 PyObject *joined = PyUnicode_Concat(repr, nrep);
1784 Py_DecRef(repr);
1785 Py_DecRef(nrep);
1786 repr = joined;
1787# else
1788 PyString_ConcatAndDel(&repr,nrep);
1789# endif
1790 } else {
1791 Py_DecRef(repr);
1792 repr = NULL;
1793 }
1794 }
1795 return repr;
1796}
1797
1798/* We need a version taking two PyObject* parameters so it's a valid
1799 * PyCFunction to use in swigobject_methods[]. */
1800SWIGRUNTIME PyObject *
1801SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1802{
1803 return SwigPyObject_repr((SwigPyObject*)v);
1804}
1805
1806SWIGRUNTIME int
1808{
1809 void *i = v->ptr;
1810 void *j = w->ptr;
1811 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1812}
1813
1814/* Added for Python 3.x, would it also be useful for Python 2.x? */
1815SWIGRUNTIME PyObject*
1817{
1818 PyObject* res = NULL;
1819 if (!PyErr_Occurred()) {
1820 if (op != Py_EQ && op != Py_NE) {
1821 Py_INCREF(Py_NotImplemented);
1822 return Py_NotImplemented;
1823 }
1824 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1825 }
1826 return res;
1827}
1828
1829
1830SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1831
1832#ifdef SWIGPYTHON_BUILTIN
1833static swig_type_info *SwigPyObject_stype = 0;
1834SWIGRUNTIME PyTypeObject*
1835SwigPyObject_type(void) {
1836 SwigPyClientData *cd;
1837 assert(SwigPyObject_stype);
1838 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1839 assert(cd);
1840 assert(cd->pytype);
1841 return cd->pytype;
1842}
1843#else
1844SWIGRUNTIME PyTypeObject*
1846 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1847 return type;
1848}
1849#endif
1850
1852SwigPyObject_Check(PyObject *op) {
1853 PyTypeObject *target_tp = SwigPyObject_type();
1854 PyTypeObject *op_type = Py_TYPE(op);
1855#ifdef SWIGPYTHON_BUILTIN
1856 if (PyType_IsSubtype(op_type, target_tp))
1857 return 1;
1858 return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
1859#else
1860 if (op_type == target_tp)
1861 return 1;
1862# ifdef Py_LIMITED_API
1863 int cmp;
1864 PyObject *tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
1865 if (!tp_name)
1866 return 0;
1867 cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject");
1868 Py_DECREF(tp_name);
1869 return cmp == 0;
1870# else
1871 return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
1872# endif
1873#endif
1874}
1875
1876SWIGRUNTIME PyObject *
1877SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1878
1879static PyObject* Swig_Capsule_global = NULL;
1880
1881SWIGRUNTIME void
1883{
1884 SwigPyObject *sobj = (SwigPyObject *) v;
1885 PyObject *next = sobj->next;
1886 if (sobj->own == SWIG_POINTER_OWN) {
1887 swig_type_info *ty = sobj->ty;
1888 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1889 PyObject *destroy = data ? data->destroy : 0;
1890 if (destroy) {
1891 /* destroy is always a VARARGS method */
1892 PyObject *res;
1893
1894 /* PyObject_CallFunction() has the potential to silently drop
1895 the active exception. In cases of unnamed temporary
1896 variable or where we just finished iterating over a generator
1897 StopIteration will be active right now, and this needs to
1898 remain true upon return from SwigPyObject_dealloc. So save
1899 and restore. */
1900
1901 PyObject *type = NULL, *value = NULL, *traceback = NULL;
1902 PyErr_Fetch(&type, &value, &traceback);
1903
1904 if (data->delargs) {
1905 /* we need to create a temporary object to carry the destroy operation */
1906 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1907 if (tmp) {
1908 res = SWIG_Python_CallFunctor(destroy, tmp);
1909 } else {
1910 res = 0;
1911 }
1912 Py_XDECREF(tmp);
1913 } else {
1914 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1915 PyObject *mself = PyCFunction_GET_SELF(destroy);
1916 res = ((*meth)(mself, v));
1917 }
1918 if (!res)
1919 PyErr_WriteUnraisable(destroy);
1920
1921 PyErr_Restore(type, value, traceback);
1922
1923 Py_XDECREF(res);
1924 }
1925#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1926 else {
1927 const char *name = SWIG_TypePrettyName(ty);
1928 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1929 }
1930#endif
1931 Py_XDECREF(Swig_Capsule_global);
1932 }
1933 Py_XDECREF(next);
1934#ifdef SWIGPYTHON_BUILTIN
1935 Py_XDECREF(sobj->dict);
1936#endif
1937 PyObject_DEL(v);
1938}
1939
1940SWIGRUNTIME PyObject*
1941SwigPyObject_append(PyObject* v, PyObject* next)
1942{
1943 SwigPyObject *sobj = (SwigPyObject *) v;
1944 if (!SwigPyObject_Check(next)) {
1945 PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1946 return NULL;
1947 }
1948 ((SwigPyObject *)next)->next = sobj->next;
1949 sobj->next = next;
1950 Py_INCREF(next);
1951 return SWIG_Py_Void();
1952}
1953
1954SWIGRUNTIME PyObject*
1955SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1956{
1957 SwigPyObject *sobj = (SwigPyObject *) v;
1958 if (sobj->next) {
1959 Py_INCREF(sobj->next);
1960 return sobj->next;
1961 } else {
1962 return SWIG_Py_Void();
1963 }
1964}
1965
1966SWIGINTERN PyObject*
1967SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1968{
1969 SwigPyObject *sobj = (SwigPyObject *)v;
1970 sobj->own = 0;
1971 return SWIG_Py_Void();
1972}
1973
1974SWIGINTERN PyObject*
1975SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1976{
1977 SwigPyObject *sobj = (SwigPyObject *)v;
1978 sobj->own = SWIG_POINTER_OWN;
1979 return SWIG_Py_Void();
1980}
1981
1982SWIGINTERN PyObject*
1983SwigPyObject_own(PyObject *v, PyObject *args)
1984{
1985 PyObject *val = 0;
1986 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
1987 return NULL;
1988 } else {
1989 SwigPyObject *sobj = (SwigPyObject *)v;
1990 PyObject *obj = PyBool_FromLong(sobj->own);
1991 if (val) {
1992 if (PyObject_IsTrue(val)) {
1993 Py_DECREF(SwigPyObject_acquire(v,args));
1994 } else {
1995 Py_DECREF(SwigPyObject_disown(v,args));
1996 }
1997 }
1998 return obj;
1999 }
2000}
2001
2002static PyMethodDef
2004 {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
2005 {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
2006 {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
2007 {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
2008 {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
2009 {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
2010 {0, 0, 0, 0}
2011};
2012
2013SWIGRUNTIME PyTypeObject*
2015 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
2016#ifndef Py_LIMITED_API
2017 static PyNumberMethods SwigPyObject_as_number = {
2018 (binaryfunc)0, /*nb_add*/
2019 (binaryfunc)0, /*nb_subtract*/
2020 (binaryfunc)0, /*nb_multiply*/
2021 /* nb_divide removed in Python 3 */
2022#if PY_VERSION_HEX < 0x03000000
2023 (binaryfunc)0, /*nb_divide*/
2024#endif
2025 (binaryfunc)0, /*nb_remainder*/
2026 (binaryfunc)0, /*nb_divmod*/
2027 (ternaryfunc)0,/*nb_power*/
2028 (unaryfunc)0, /*nb_negative*/
2029 (unaryfunc)0, /*nb_positive*/
2030 (unaryfunc)0, /*nb_absolute*/
2031 (inquiry)0, /*nb_nonzero*/
2032 0, /*nb_invert*/
2033 0, /*nb_lshift*/
2034 0, /*nb_rshift*/
2035 0, /*nb_and*/
2036 0, /*nb_xor*/
2037 0, /*nb_or*/
2038#if PY_VERSION_HEX < 0x03000000
2039 0, /*nb_coerce*/
2040#endif
2041 (unaryfunc)SwigPyObject_long, /*nb_int*/
2042#if PY_VERSION_HEX < 0x03000000
2043 (unaryfunc)SwigPyObject_long, /*nb_long*/
2044#else
2045 0, /*nb_reserved*/
2046#endif
2047 (unaryfunc)0, /*nb_float*/
2048#if PY_VERSION_HEX < 0x03000000
2049 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
2050 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
2051#endif
2052#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
2053 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
2054#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
2055 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
2056#else
2057 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
2058#endif
2059 };
2060
2061 static PyTypeObject swigpyobject_type;
2062 static int type_init = 0;
2063 if (!type_init) {
2064 const PyTypeObject tmp = {
2065#if PY_VERSION_HEX >= 0x03000000
2066 PyVarObject_HEAD_INIT(NULL, 0)
2067#else
2068 PyObject_HEAD_INIT(NULL)
2069 0, /* ob_size */
2070#endif
2071 "SwigPyObject", /* tp_name */
2072 sizeof(SwigPyObject), /* tp_basicsize */
2073 0, /* tp_itemsize */
2074 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
2075#if PY_VERSION_HEX < 0x030800b4
2076 (printfunc)0, /*tp_print*/
2077#else
2078 (Py_ssize_t)0, /*tp_vectorcall_offset*/
2079#endif
2080 (getattrfunc)0, /* tp_getattr */
2081 (setattrfunc)0, /* tp_setattr */
2082#if PY_VERSION_HEX >= 0x03000000
2083 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
2084#else
2085 (cmpfunc)SwigPyObject_compare, /* tp_compare */
2086#endif
2087 (reprfunc)SwigPyObject_repr, /* tp_repr */
2088 &SwigPyObject_as_number, /* tp_as_number */
2089 0, /* tp_as_sequence */
2090 0, /* tp_as_mapping */
2091 (hashfunc)0, /* tp_hash */
2092 (ternaryfunc)0, /* tp_call */
2093 0, /* tp_str */
2094 PyObject_GenericGetAttr, /* tp_getattro */
2095 0, /* tp_setattro */
2096 0, /* tp_as_buffer */
2097 Py_TPFLAGS_DEFAULT, /* tp_flags */
2098 swigobject_doc, /* tp_doc */
2099 0, /* tp_traverse */
2100 0, /* tp_clear */
2101 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
2102 0, /* tp_weaklistoffset */
2103 0, /* tp_iter */
2104 0, /* tp_iternext */
2105 swigobject_methods, /* tp_methods */
2106 0, /* tp_members */
2107 0, /* tp_getset */
2108 0, /* tp_base */
2109 0, /* tp_dict */
2110 0, /* tp_descr_get */
2111 0, /* tp_descr_set */
2112 0, /* tp_dictoffset */
2113 0, /* tp_init */
2114 0, /* tp_alloc */
2115 0, /* tp_new */
2116 0, /* tp_free */
2117 0, /* tp_is_gc */
2118 0, /* tp_bases */
2119 0, /* tp_mro */
2120 0, /* tp_cache */
2121 0, /* tp_subclasses */
2122 0, /* tp_weaklist */
2123 0, /* tp_del */
2124 0, /* tp_version_tag */
2125#if PY_VERSION_HEX >= 0x03040000
2126 0, /* tp_finalize */
2127#endif
2128#if PY_VERSION_HEX >= 0x03080000
2129 0, /* tp_vectorcall */
2130#endif
2131#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2132 0, /* tp_print */
2133#endif
2134#if PY_VERSION_HEX >= 0x030C0000
2135 0, /* tp_watched */
2136#endif
2137#ifdef COUNT_ALLOCS
2138 0, /* tp_allocs */
2139 0, /* tp_frees */
2140 0, /* tp_maxalloc */
2141 0, /* tp_prev */
2142 0 /* tp_next */
2143#endif
2144 };
2145 swigpyobject_type = tmp;
2146 type_init = 1;
2147 if (PyType_Ready(&swigpyobject_type) != 0)
2148 return NULL;
2149 }
2150 return &swigpyobject_type;
2151#else
2152 PyType_Slot slots[] = {
2153 { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
2154 { Py_tp_repr, (void *)SwigPyObject_repr },
2155 { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
2156 { Py_tp_doc, (void *)swigobject_doc },
2157 { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
2158 { Py_tp_methods, (void *)swigobject_methods },
2159 { Py_nb_int, (void *)SwigPyObject_long },
2160 { 0, NULL }
2161 };
2162 PyType_Spec spec = {
2163 "SwigPyObject",
2164 sizeof(SwigPyObject),
2165 0,
2166 Py_TPFLAGS_DEFAULT,
2167 slots
2168 };
2169 return (PyTypeObject *)PyType_FromSpec(&spec);
2170#endif
2171}
2172
2173SWIGRUNTIME PyObject *
2174SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2175{
2176 SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_type());
2177 if (sobj) {
2178 sobj->ptr = ptr;
2179 sobj->ty = ty;
2180 sobj->own = own;
2181 sobj->next = 0;
2182#ifdef SWIGPYTHON_BUILTIN
2183 sobj->dict = 0;
2184#endif
2185 if (own == SWIG_POINTER_OWN) {
2186 /* Obtain a reference to the Python capsule wrapping the module information, so that the
2187 * module information is correctly destroyed after all SWIG python objects have been freed
2188 * by the GC (and corresponding destructors invoked) */
2189 Py_XINCREF(Swig_Capsule_global);
2190 }
2191 }
2192 return (PyObject *)sobj;
2193}
2194
2195/* -----------------------------------------------------------------------------
2196 * Implements a simple Swig Packed type, and use it instead of string
2197 * ----------------------------------------------------------------------------- */
2198
2199typedef struct {
2200 PyObject_HEAD
2201 void *pack;
2203 size_t size;
2204} SwigPyPacked;
2205
2206SWIGRUNTIME PyObject *
2208{
2209 char result[SWIG_BUFFER_SIZE];
2210 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2211 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2212 } else {
2213 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2214 }
2215}
2216
2217SWIGRUNTIME PyObject *
2219{
2220 char result[SWIG_BUFFER_SIZE];
2221 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2222 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2223 } else {
2224 return SWIG_Python_str_FromChar(v->ty->name);
2225 }
2226}
2227
2228SWIGRUNTIME int
2230{
2231 size_t i = v->size;
2232 size_t j = w->size;
2233 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2234 return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
2235}
2236
2237SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2238
2239SWIGRUNTIME PyTypeObject*
2241 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2242 return type;
2243}
2244
2246SwigPyPacked_Check(PyObject *op) {
2247 PyTypeObject* op_type = Py_TYPE(op);
2248 if (op_type == SwigPyPacked_TypeOnce())
2249 return 1;
2250#ifdef Py_LIMITED_API
2251 int cmp;
2252 PyObject *tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
2253 if (!tp_name)
2254 return 0;
2255 cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked");
2256 Py_DECREF(tp_name);
2257 return cmp == 0;
2258#else
2259 return (strcmp(op_type->tp_name, "SwigPyPacked") == 0);
2260#endif
2261}
2262
2263SWIGRUNTIME void
2265{
2266 if (SwigPyPacked_Check(v)) {
2267 SwigPyPacked *sobj = (SwigPyPacked *) v;
2268 free(sobj->pack);
2269 }
2270 PyObject_DEL(v);
2271}
2272
2273SWIGRUNTIME PyTypeObject*
2275 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2276#ifndef Py_LIMITED_API
2277 static PyTypeObject swigpypacked_type;
2278 static int type_init = 0;
2279 if (!type_init) {
2280 const PyTypeObject tmp = {
2281#if PY_VERSION_HEX>=0x03000000
2282 PyVarObject_HEAD_INIT(NULL, 0)
2283#else
2284 PyObject_HEAD_INIT(NULL)
2285 0, /* ob_size */
2286#endif
2287 "SwigPyPacked", /* tp_name */
2288 sizeof(SwigPyPacked), /* tp_basicsize */
2289 0, /* tp_itemsize */
2290 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2291#if PY_VERSION_HEX < 0x030800b4
2292 (printfunc)0, /*tp_print*/
2293#else
2294 (Py_ssize_t)0, /*tp_vectorcall_offset*/
2295#endif
2296 (getattrfunc)0, /* tp_getattr */
2297 (setattrfunc)0, /* tp_setattr */
2298#if PY_VERSION_HEX>=0x03000000
2299 0, /* tp_reserved in 3.0.1 */
2300#else
2301 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2302#endif
2303 (reprfunc)SwigPyPacked_repr, /* tp_repr */
2304 0, /* tp_as_number */
2305 0, /* tp_as_sequence */
2306 0, /* tp_as_mapping */
2307 (hashfunc)0, /* tp_hash */
2308 (ternaryfunc)0, /* tp_call */
2309 (reprfunc)SwigPyPacked_str, /* tp_str */
2310 PyObject_GenericGetAttr, /* tp_getattro */
2311 0, /* tp_setattro */
2312 0, /* tp_as_buffer */
2313 Py_TPFLAGS_DEFAULT, /* tp_flags */
2314 swigpacked_doc, /* tp_doc */
2315 0, /* tp_traverse */
2316 0, /* tp_clear */
2317 0, /* tp_richcompare */
2318 0, /* tp_weaklistoffset */
2319 0, /* tp_iter */
2320 0, /* tp_iternext */
2321 0, /* tp_methods */
2322 0, /* tp_members */
2323 0, /* tp_getset */
2324 0, /* tp_base */
2325 0, /* tp_dict */
2326 0, /* tp_descr_get */
2327 0, /* tp_descr_set */
2328 0, /* tp_dictoffset */
2329 0, /* tp_init */
2330 0, /* tp_alloc */
2331 0, /* tp_new */
2332 0, /* tp_free */
2333 0, /* tp_is_gc */
2334 0, /* tp_bases */
2335 0, /* tp_mro */
2336 0, /* tp_cache */
2337 0, /* tp_subclasses */
2338 0, /* tp_weaklist */
2339 0, /* tp_del */
2340 0, /* tp_version_tag */
2341#if PY_VERSION_HEX >= 0x03040000
2342 0, /* tp_finalize */
2343#endif
2344#if PY_VERSION_HEX >= 0x03080000
2345 0, /* tp_vectorcall */
2346#endif
2347#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2348 0, /* tp_print */
2349#endif
2350#if PY_VERSION_HEX >= 0x030C0000
2351 0, /* tp_watched */
2352#endif
2353#ifdef COUNT_ALLOCS
2354 0, /* tp_allocs */
2355 0, /* tp_frees */
2356 0, /* tp_maxalloc */
2357 0, /* tp_prev */
2358 0 /* tp_next */
2359#endif
2360 };
2361 swigpypacked_type = tmp;
2362 type_init = 1;
2363 if (PyType_Ready(&swigpypacked_type) != 0)
2364 return NULL;
2365 }
2366 return &swigpypacked_type;
2367#else
2368 PyType_Slot slots[] = {
2369 { Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
2370 { Py_tp_repr, (void *)SwigPyPacked_repr },
2371 { Py_tp_str, (void *)SwigPyPacked_str },
2372 { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
2373 { Py_tp_doc, (void *)swigpacked_doc },
2374 { 0, NULL }
2375 };
2376 PyType_Spec spec = {
2377 "SwigPyPacked",
2378 sizeof(SwigPyPacked),
2379 0,
2380 Py_TPFLAGS_DEFAULT,
2381 slots
2382 };
2383 return (PyTypeObject *)PyType_FromSpec(&spec);
2384#endif
2385}
2386
2387SWIGRUNTIME PyObject *
2388SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2389{
2390 SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_type());
2391 if (sobj) {
2392 void *pack = malloc(size);
2393 if (pack) {
2394 memcpy(pack, ptr, size);
2395 sobj->pack = pack;
2396 sobj->ty = ty;
2397 sobj->size = size;
2398 } else {
2399 PyObject_DEL((PyObject *) sobj);
2400 sobj = 0;
2401 }
2402 }
2403 return (PyObject *) sobj;
2404}
2405
2407SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2408{
2409 if (SwigPyPacked_Check(obj)) {
2410 SwigPyPacked *sobj = (SwigPyPacked *)obj;
2411 if (sobj->size != size) return 0;
2412 memcpy(ptr, sobj->pack, size);
2413 return sobj->ty;
2414 } else {
2415 return 0;
2416 }
2417}
2418
2419/* -----------------------------------------------------------------------------
2420 * pointers/data manipulation
2421 * ----------------------------------------------------------------------------- */
2422
2423static PyObject *Swig_This_global = NULL;
2424
2425SWIGRUNTIME PyObject *
2427{
2428 if (Swig_This_global == NULL)
2430 return Swig_This_global;
2431}
2432
2433/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2434
2435/* TODO: I don't know how to implement the fast getset in Python 3 right now */
2436#if PY_VERSION_HEX>=0x03000000
2437#define SWIG_PYTHON_SLOW_GETSET_THIS
2438#endif
2439
2442{
2443 PyObject *obj;
2444
2445 if (SwigPyObject_Check(pyobj))
2446 return (SwigPyObject *) pyobj;
2447
2448#ifdef SWIGPYTHON_BUILTIN
2449 (void)obj;
2450# ifdef PyWeakref_CheckProxy
2451 if (PyWeakref_CheckProxy(pyobj)) {
2452#if PY_VERSION_HEX >= 0x030D0000
2453 PyWeakref_GetRef(pyobj, &pyobj);
2454 Py_DECREF(pyobj);
2455#else
2456 pyobj = PyWeakref_GET_OBJECT(pyobj);
2457#endif
2458 if (pyobj && SwigPyObject_Check(pyobj))
2459 return (SwigPyObject*) pyobj;
2460 }
2461# endif
2462 return NULL;
2463#else
2464
2465 obj = 0;
2466
2467#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2468 if (PyInstance_Check(pyobj)) {
2469 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2470 } else {
2471 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2472 if (dictptr != NULL) {
2473 PyObject *dict = *dictptr;
2474 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2475 } else {
2476#ifdef PyWeakref_CheckProxy
2477 if (PyWeakref_CheckProxy(pyobj)) {
2478 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2479 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2480 }
2481#endif
2482 obj = PyObject_GetAttr(pyobj,SWIG_This());
2483 if (obj) {
2484 Py_DECREF(obj);
2485 } else {
2486 if (PyErr_Occurred()) PyErr_Clear();
2487 return 0;
2488 }
2489 }
2490 }
2491#else
2492 obj = PyObject_GetAttr(pyobj,SWIG_This());
2493 if (obj) {
2494 Py_DECREF(obj);
2495 } else {
2496 if (PyErr_Occurred()) PyErr_Clear();
2497 return 0;
2498 }
2499#endif
2500 if (obj && !SwigPyObject_Check(obj)) {
2501 /* a PyObject is called 'this', try to get the 'real this'
2502 SwigPyObject from it */
2503 return SWIG_Python_GetSwigThis(obj);
2504 }
2505 return (SwigPyObject *)obj;
2506#endif
2507}
2508
2509/* Acquire a pointer value */
2510
2511SWIGRUNTIME int
2512SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2513 if (own == SWIG_POINTER_OWN) {
2515 if (sobj) {
2516 int oldown = sobj->own;
2517 sobj->own = own;
2518 return oldown;
2519 }
2520 }
2521 return 0;
2522}
2523
2524/* Convert a pointer value */
2525
2526SWIGRUNTIME int
2527SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2528 int res;
2529 SwigPyObject *sobj;
2530 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2531
2532 if (!obj)
2533 return SWIG_ERROR;
2534 if (obj == Py_None && !implicit_conv) {
2535 if (ptr)
2536 *ptr = 0;
2538 }
2539
2540 res = SWIG_ERROR;
2541
2542 sobj = SWIG_Python_GetSwigThis(obj);
2543 if (own)
2544 *own = 0;
2545 while (sobj) {
2546 void *vptr = sobj->ptr;
2547 if (ty) {
2548 swig_type_info *to = sobj->ty;
2549 if (to == ty) {
2550 /* no type cast needed */
2551 if (ptr) *ptr = vptr;
2552 break;
2553 } else {
2554 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2555 if (!tc) {
2556 sobj = (SwigPyObject *)sobj->next;
2557 } else {
2558 if (ptr) {
2559 int newmemory = 0;
2560 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2561 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2562 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2563 if (own)
2564 *own = *own | SWIG_CAST_NEW_MEMORY;
2565 }
2566 }
2567 break;
2568 }
2569 }
2570 } else {
2571 if (ptr) *ptr = vptr;
2572 break;
2573 }
2574 }
2575 if (sobj) {
2576 if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
2578 } else {
2579 if (own)
2580 *own = *own | sobj->own;
2581 if (flags & SWIG_POINTER_DISOWN) {
2582 sobj->own = 0;
2583 }
2584 if (flags & SWIG_POINTER_CLEAR) {
2585 sobj->ptr = 0;
2586 }
2587 res = SWIG_OK;
2588 }
2589 } else {
2590 if (implicit_conv) {
2591 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2592 if (data && !data->implicitconv) {
2593 PyObject *klass = data->klass;
2594 if (klass) {
2595 PyObject *impconv;
2596 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2597 impconv = SWIG_Python_CallFunctor(klass, obj);
2598 data->implicitconv = 0;
2599 if (PyErr_Occurred()) {
2600 PyErr_Clear();
2601 impconv = 0;
2602 }
2603 if (impconv) {
2604 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2605 if (iobj) {
2606 void *vptr;
2607 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2608 if (SWIG_IsOK(res)) {
2609 if (ptr) {
2610 *ptr = vptr;
2611 /* transfer the ownership to 'ptr' */
2612 iobj->own = 0;
2613 res = SWIG_AddCast(res);
2614 res = SWIG_AddNewMask(res);
2615 } else {
2616 res = SWIG_AddCast(res);
2617 }
2618 }
2619 }
2620 Py_DECREF(impconv);
2621 }
2622 }
2623 }
2624 if (!SWIG_IsOK(res) && obj == Py_None) {
2625 if (ptr)
2626 *ptr = 0;
2627 if (PyErr_Occurred())
2628 PyErr_Clear();
2629 res = SWIG_OK;
2630 }
2631 }
2632 }
2633 return res;
2634}
2635
2636/* Convert a function ptr value */
2637
2638SWIGRUNTIME int
2639SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2640 if (!PyCFunction_Check(obj)) {
2641 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2642 } else {
2643 void *vptr = 0;
2644 swig_cast_info *tc;
2645
2646 /* here we get the method pointer for callbacks */
2647#ifndef Py_LIMITED_API
2648 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2649#else
2650 PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
2651 PyObject *bytes = NULL;
2652 const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
2653#endif
2654 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2655 if (desc)
2656 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2657#ifdef Py_LIMITED_API
2658 Py_XDECREF(bytes);
2659 Py_XDECREF(pystr_doc);
2660#endif
2661 if (!desc)
2662 return SWIG_ERROR;
2663 tc = SWIG_TypeCheck(desc,ty);
2664 if (tc) {
2665 int newmemory = 0;
2666 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2667 assert(!newmemory); /* newmemory handling not yet implemented */
2668 } else {
2669 return SWIG_ERROR;
2670 }
2671 return SWIG_OK;
2672 }
2673}
2674
2675/* Convert a packed pointer value */
2676
2677SWIGRUNTIME int
2678SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2679 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2680 if (!to) return SWIG_ERROR;
2681 if (ty) {
2682 if (to != ty) {
2683 /* check type cast? */
2684 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2685 if (!tc) return SWIG_ERROR;
2686 }
2687 }
2688 return SWIG_OK;
2689}
2690
2691/* -----------------------------------------------------------------------------
2692 * Create a new pointer object
2693 * ----------------------------------------------------------------------------- */
2694
2695/*
2696 Create a new instance object, without calling __init__, and set the
2697 'this' attribute.
2698*/
2699
2700SWIGRUNTIME PyObject*
2702{
2703 PyObject *inst = 0;
2704 PyObject *newraw = data->newraw;
2705 if (newraw) {
2706 inst = PyObject_Call(newraw, data->newargs, NULL);
2707 if (inst) {
2708#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2709 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2710 if (dictptr != NULL) {
2711 PyObject *dict = *dictptr;
2712 if (dict == NULL) {
2713 dict = PyDict_New();
2714 *dictptr = dict;
2715 }
2716 if (dict) {
2717 PyDict_SetItem(dict, SWIG_This(), swig_this);
2718 } else{
2719 Py_DECREF(inst);
2720 inst = 0;
2721 }
2722 }
2723#else
2724 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2725 Py_DECREF(inst);
2726 inst = 0;
2727 }
2728#endif
2729 }
2730 } else {
2731#if PY_VERSION_HEX >= 0x03000000
2732 PyObject *empty_args = PyTuple_New(0);
2733 if (empty_args) {
2734 PyObject *empty_kwargs = PyDict_New();
2735 if (empty_kwargs) {
2736#ifndef Py_LIMITED_API
2737 newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
2738#else
2739 newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
2740#endif
2741 inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
2742 Py_DECREF(empty_kwargs);
2743 if (inst) {
2744 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2745 Py_DECREF(inst);
2746 inst = 0;
2747 } else {
2748 PyType_Modified(Py_TYPE(inst));
2749 }
2750 }
2751 }
2752 Py_DECREF(empty_args);
2753 }
2754#else
2755 PyObject *dict = PyDict_New();
2756 if (dict) {
2757 PyDict_SetItem(dict, SWIG_This(), swig_this);
2758 inst = PyInstance_NewRaw(data->newargs, dict);
2759 Py_DECREF(dict);
2760 }
2761#endif
2762 }
2763 return inst;
2764}
2765
2766SWIGRUNTIME int
2767SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2768{
2769#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2770 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2771 if (dictptr != NULL) {
2772 PyObject *dict = *dictptr;
2773 if (dict == NULL) {
2774 dict = PyDict_New();
2775 *dictptr = dict;
2776 }
2777 if (dict) {
2778 return PyDict_SetItem(dict, SWIG_This(), swig_this);
2779 } else{
2780 return -1;
2781 }
2782 }
2783#endif
2784 return PyObject_SetAttr(inst, SWIG_This(), swig_this);
2785}
2786
2787
2788SWIGINTERN PyObject *
2790 PyObject *obj[2];
2791 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2792 return NULL;
2793 } else {
2794 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2795 if (sthis) {
2796 Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
2797 } else {
2798 if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
2799 return NULL;
2800 }
2801 return SWIG_Py_Void();
2802 }
2803}
2804
2805/* Create a new pointer object */
2806
2807SWIGRUNTIME PyObject *
2808SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2809 SwigPyClientData *clientdata;
2810 PyObject * robj;
2811 int own;
2812
2813 if (!ptr)
2814 return SWIG_Py_Void();
2815
2816 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2817 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2818 if (clientdata && clientdata->pytype) {
2819 SwigPyObject *newobj;
2820 if (flags & SWIG_BUILTIN_TP_INIT) {
2821 newobj = (SwigPyObject*) self;
2822 if (newobj->ptr) {
2823#ifndef Py_LIMITED_API
2824 allocfunc alloc = clientdata->pytype->tp_alloc;
2825#else
2826 allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
2827#endif
2828 PyObject *next_self = alloc(clientdata->pytype, 0);
2829 while (newobj->next)
2830 newobj = (SwigPyObject *) newobj->next;
2831 newobj->next = next_self;
2832 newobj = (SwigPyObject *)next_self;
2833#ifdef SWIGPYTHON_BUILTIN
2834 newobj->dict = 0;
2835#endif
2836 }
2837 } else {
2838 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2839#ifdef SWIGPYTHON_BUILTIN
2840 if (newobj) {
2841 newobj->dict = 0;
2842 }
2843#endif
2844 }
2845 if (newobj) {
2846 newobj->ptr = ptr;
2847 newobj->ty = type;
2848 newobj->own = own;
2849 newobj->next = 0;
2850 return (PyObject*) newobj;
2851 }
2852 return SWIG_Py_Void();
2853 }
2854
2855 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2856
2857 robj = SwigPyObject_New(ptr, type, own);
2858 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2859 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2860 Py_DECREF(robj);
2861 robj = inst;
2862 }
2863 return robj;
2864}
2865
2866/* Create a new packed object */
2867
2868SWIGRUNTIMEINLINE PyObject *
2869SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2870 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2871}
2872
2873/* -----------------------------------------------------------------------------*
2874 * Get type list
2875 * -----------------------------------------------------------------------------*/
2876
2877#ifdef SWIG_LINK_RUNTIME
2878void *SWIG_ReturnGlobalTypeList(void *);
2879#endif
2880
2881static PyObject *Swig_TypeCache_global = NULL;
2882
2883/* The python cached type query */
2884SWIGRUNTIME PyObject *
2886 if (Swig_TypeCache_global == NULL) {
2887 Swig_TypeCache_global = PyDict_New();
2888 }
2889 return Swig_TypeCache_global;
2890}
2891
2894#ifdef SWIG_LINK_RUNTIME
2895 static void *type_pointer = (void *)0;
2896 /* first check if module already created */
2897 if (!type_pointer) {
2898 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2899 }
2900#else
2901 void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2902 if (PyErr_Occurred()) {
2903 PyErr_Clear();
2904 type_pointer = (void *)0;
2905 }
2906#endif
2907 return (swig_module_info *) type_pointer;
2908}
2909
2910
2911static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */
2912
2913SWIGRUNTIME void
2915{
2916 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2917 swig_type_info **types = swig_module->types;
2918 size_t i;
2919 if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
2920 return;
2921 for (i =0; i < swig_module->size; ++i) {
2922 swig_type_info *ty = types[i];
2923 if (ty->owndata) {
2925 ty->clientdata = 0;
2926 if (data) SwigPyClientData_Del(data);
2927 }
2928 }
2929 Py_DECREF(SWIG_This());
2930 Swig_This_global = NULL;
2931 Py_DECREF(SWIG_globals());
2932 Swig_Globals_global = NULL;
2933 Py_DECREF(SWIG_Python_TypeCache());
2934 Swig_TypeCache_global = NULL;
2935 Swig_Capsule_global = NULL;
2936}
2937
2938SWIGRUNTIME void
2940#if PY_VERSION_HEX >= 0x03000000
2941 /* Add a dummy module object into sys.modules */
2942 PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2943#else
2944 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2945 PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2946#endif
2947 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2948 if (pointer && module) {
2949 if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
2951 Swig_Capsule_global = pointer;
2952 } else {
2953 Py_DECREF(pointer);
2954 }
2955 } else {
2956 Py_XDECREF(pointer);
2957 }
2958}
2959
2961SWIG_Python_TypeQuery(const char *type)
2962{
2963 PyObject *cache = SWIG_Python_TypeCache();
2964 PyObject *key = SWIG_Python_str_FromChar(type);
2965 PyObject *obj = PyDict_GetItem(cache, key);
2966 swig_type_info *descriptor;
2967 if (obj) {
2968 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2969 } else {
2971 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2972 if (descriptor) {
2973 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2974 if (obj) {
2975 PyDict_SetItem(cache, key, obj);
2976 Py_DECREF(obj);
2977 }
2978 }
2979 }
2980 Py_DECREF(key);
2981 return descriptor;
2982}
2983
2984/*
2985 For backward compatibility only
2986*/
2987#define SWIG_POINTER_EXCEPTION 0
2988#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2989#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2990
2991SWIGRUNTIME int
2992SWIG_Python_AddErrMesg(const char* mesg, int infront)
2993{
2994 if (PyErr_Occurred()) {
2995 PyObject *type = 0;
2996 PyObject *value = 0;
2997 PyObject *traceback = 0;
2998 PyErr_Fetch(&type, &value, &traceback);
2999 if (value) {
3000 PyObject *old_str = PyObject_Str(value);
3001 PyObject *bytes = NULL;
3002 const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
3003 const char *errmesg = tmp ? tmp : "Invalid error message";
3004 Py_XINCREF(type);
3005 PyErr_Clear();
3006 if (infront) {
3007 PyErr_Format(type, "%s %s", mesg, errmesg);
3008 } else {
3009 PyErr_Format(type, "%s %s", errmesg, mesg);
3010 }
3011 Py_XDECREF(bytes);
3012 Py_DECREF(old_str);
3013 }
3014 return 1;
3015 } else {
3016 return 0;
3017 }
3018}
3019
3020SWIGRUNTIME int
3022{
3023 if (PyErr_Occurred()) {
3024 /* add information about failing argument */
3025 char mesg[256];
3026 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
3027 return SWIG_Python_AddErrMesg(mesg, 1);
3028 } else {
3029 return 0;
3030 }
3031}
3032
3033SWIGRUNTIMEINLINE const char *
3035{
3036 SwigPyObject *v = (SwigPyObject *)self;
3037 swig_type_info *ty = v ? v->ty : 0;
3038 return ty ? ty->str : "";
3039}
3040
3041SWIGRUNTIME void
3042SWIG_Python_TypeError(const char *type, PyObject *obj)
3043{
3044 if (type) {
3045#if defined(SWIG_COBJECT_TYPES)
3046 if (obj && SwigPyObject_Check(obj)) {
3047 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
3048 if (otype) {
3049 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
3050 type, otype);
3051 return;
3052 }
3053 } else
3054#endif
3055 {
3056#ifndef Py_LIMITED_API
3057 /* tp_name is not accessible */
3058 const char *otype = (obj ? obj->ob_type->tp_name : 0);
3059 if (otype) {
3060 PyObject *str = PyObject_Str(obj);
3061 PyObject *bytes = NULL;
3062 const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0;
3063 if (cstr) {
3064 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
3065 type, otype, cstr);
3066 } else {
3067 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
3068 type, otype);
3069 }
3070 Py_XDECREF(bytes);
3071 Py_XDECREF(str);
3072 return;
3073 }
3074#endif
3075 }
3076 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
3077 } else {
3078 PyErr_Format(PyExc_TypeError, "unexpected type is received");
3079 }
3080}
3081
3082
3083/* Convert a pointer value, signal an exception on a type mismatch */
3084SWIGRUNTIME void *
3085SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
3086 void *result;
3087 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
3088 PyErr_Clear();
3089 }
3090 return result;
3091}
3092
3093#ifdef SWIGPYTHON_BUILTIN
3094SWIGRUNTIME int
3095SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
3096 PyTypeObject *tp = obj->ob_type;
3097 PyObject *descr;
3098 PyObject *encoded_name;
3099 descrsetfunc f;
3100 int res = -1;
3101
3102# ifdef Py_USING_UNICODE
3103 if (PyString_Check(name)) {
3104 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
3105 if (!name)
3106 return -1;
3107 } else if (!PyUnicode_Check(name))
3108# else
3109 if (!PyString_Check(name))
3110# endif
3111 {
3112 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
3113 return -1;
3114 } else {
3115 Py_INCREF(name);
3116 }
3117
3118 if (!tp->tp_dict) {
3119 if (PyType_Ready(tp) != 0)
3120 goto done;
3121 }
3122
3123 descr = _PyType_Lookup(tp, name);
3124 f = NULL;
3125 if (descr != NULL)
3126 f = descr->ob_type->tp_descr_set;
3127 if (!f) {
3128 if (PyString_Check(name)) {
3129 encoded_name = name;
3130 Py_INCREF(name);
3131 } else {
3132 encoded_name = PyUnicode_AsUTF8String(name);
3133 if (!encoded_name)
3134 goto done;
3135 }
3136 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
3137 Py_DECREF(encoded_name);
3138 } else {
3139 res = f(descr, obj, value);
3140 }
3141
3142 done:
3143 Py_DECREF(name);
3144 return res;
3145}
3146#endif
3147
3148
3149#ifdef __cplusplus
3150}
3151#endif
3152
3153
3154
3155#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3156
3157#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
3158
3159
3160
3161/* -------- TYPES TABLE (BEGIN) -------- */
3162
3163#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
3164#define SWIGTYPE_p_PLcGrid swig_types[1]
3165#define SWIGTYPE_p_PLcGrid2 swig_types[2]
3166#define SWIGTYPE_p_char swig_types[3]
3167#define SWIGTYPE_p_double swig_types[4]
3168#define SWIGTYPE_p_f_double_double__int swig_types[5]
3169#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
3170#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
3171#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
3172#define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
3173#define SWIGTYPE_p_int swig_types[10]
3174#define SWIGTYPE_p_p_char swig_types[11]
3175#define SWIGTYPE_p_p_double swig_types[12]
3176#define SWIGTYPE_p_unsigned_int swig_types[13]
3178static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
3179#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3180#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3181
3182/* -------- TYPES TABLE (END) -------- */
3183
3184#ifdef SWIG_TypeQuery
3185# undef SWIG_TypeQuery
3186#endif
3187#define SWIG_TypeQuery SWIG_Python_TypeQuery
3188
3189/*-----------------------------------------------
3190 @(target):= _plplotc.so
3191 ------------------------------------------------*/
3192#if PY_VERSION_HEX >= 0x03000000
3193# define SWIG_init PyInit__plplotc
3194
3195#else
3196# define SWIG_init init_plplotc
3197
3198#endif
3199#define SWIG_name "_plplotc"
3200
3201#define SWIG_as_voidptr(a) (void *)((const void *)(a))
3202#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3203
3204
3205#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
3206#include <arrayobject.h>
3207#include "plplot.h"
3208#include "plplotP.h"
3209
3210#define NPY_PLINT NPY_INT32
3211
3212#ifdef PL_DOUBLE
3213#define NPY_PLFLT NPY_FLOAT64
3214#else
3215#define NPY_PLFLT NPY_FLOAT32
3216#endif
3217
3218// python-1.5 compatibility mode?
3219#if !defined ( PySequence_Fast_GET_ITEM )
3220 #define PySequence_Fast_GET_ITEM PySequence_GetItem
3221#endif
3222#define PySequence_Size PySequence_Length
3223
3224
3225 static PLINT Alen = 0;
3226 static PLINT Xlen = 0, Ylen = 0;
3227
3228
3229SWIGINTERN int
3230SWIG_AsVal_double (PyObject *obj, double *val)
3231{
3232 int res = SWIG_TypeError;
3233 if (PyFloat_Check(obj)) {
3234 if (val) *val = PyFloat_AsDouble(obj);
3235 return SWIG_OK;
3236#if PY_VERSION_HEX < 0x03000000
3237 } else if (PyInt_Check(obj)) {
3238 if (val) *val = (double) PyInt_AsLong(obj);
3239 return SWIG_OK;
3240#endif
3241 } else if (PyLong_Check(obj)) {
3242 double v = PyLong_AsDouble(obj);
3243 if (!PyErr_Occurred()) {
3244 if (val) *val = v;
3245 return SWIG_OK;
3246 } else {
3247 PyErr_Clear();
3248 }
3249 }
3250#ifdef SWIG_PYTHON_CAST_MODE
3251 {
3252 int dispatch = 0;
3253 double d = PyFloat_AsDouble(obj);
3254 if (!PyErr_Occurred()) {
3255 if (val) *val = d;
3256 return SWIG_AddCast(SWIG_OK);
3257 } else {
3258 PyErr_Clear();
3259 }
3260 if (!dispatch) {
3261 long v = PyLong_AsLong(obj);
3262 if (!PyErr_Occurred()) {
3263 if (val) *val = v;
3265 } else {
3266 PyErr_Clear();
3267 }
3268 }
3269 }
3270#endif
3271 return res;
3272}
3273
3274
3275 #define SWIG_From_double PyFloat_FromDouble
3276
3277
3278 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3279 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3280 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3281 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3282 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3284 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3285
3286
3287SWIGINTERNINLINE PyObject*
3289{
3290 return PyInt_FromLong((long) value);
3291}
3292
3293
3294#include <limits.h>
3295#if !defined(SWIG_NO_LLONG_MAX)
3296# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3297# define LLONG_MAX __LONG_LONG_MAX__
3298# define LLONG_MIN (-LLONG_MAX - 1LL)
3299# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3300# endif
3301#endif
3302
3303
3304#include <float.h>
3305
3306
3307#include <math.h>
3308
3309
3311SWIG_CanCastAsInteger(double *d, double min, double max) {
3312 double x = *d;
3313 if ((min <= x && x <= max)) {
3314 double fx, cx, rd;
3315 errno = 0;
3316 fx = floor(x);
3317 cx = ceil(x);
3318 rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3319 if ((errno == EDOM) || (errno == ERANGE)) {
3320 errno = 0;
3321 } else {
3322 double summ, reps, diff;
3323 if (rd < x) {
3324 diff = x - rd;
3325 } else if (rd > x) {
3326 diff = rd - x;
3327 } else {
3328 return 1;
3329 }
3330 summ = rd + x;
3331 reps = diff/summ;
3332 if (reps < 8*DBL_EPSILON) {
3333 *d = rd;
3334 return 1;
3335 }
3336 }
3337 }
3338 return 0;
3339}
3340
3341
3342SWIGINTERN int
3343SWIG_AsVal_long (PyObject *obj, long* val)
3344{
3345#if PY_VERSION_HEX < 0x03000000
3346 if (PyInt_Check(obj)) {
3347 if (val) *val = PyInt_AsLong(obj);
3348 return SWIG_OK;
3349 } else
3350#endif
3351 if (PyLong_Check(obj)) {
3352 long v = PyLong_AsLong(obj);
3353 if (!PyErr_Occurred()) {
3354 if (val) *val = v;
3355 return SWIG_OK;
3356 } else {
3357 PyErr_Clear();
3358 return SWIG_OverflowError;
3359 }
3360 }
3361#ifdef SWIG_PYTHON_CAST_MODE
3362 {
3363 int dispatch = 0;
3364 long v = PyInt_AsLong(obj);
3365 if (!PyErr_Occurred()) {
3366 if (val) *val = v;
3367 return SWIG_AddCast(SWIG_OK);
3368 } else {
3369 PyErr_Clear();
3370 }
3371 if (!dispatch) {
3372 double d;
3373 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3374 // Largest double not larger than LONG_MAX (not portably calculated easily)
3375 // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
3376 // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
3377 const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
3378 // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
3379 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
3380 if (val) *val = (long)(d);
3381 return res;
3382 }
3383 }
3384 }
3385#endif
3386 return SWIG_TypeError;
3387}
3388
3389
3390SWIGINTERN int
3391SWIG_AsVal_int (PyObject * obj, int *val)
3392{
3393 long v;
3394 int res = SWIG_AsVal_long (obj, &v);
3395 if (SWIG_IsOK(res)) {
3396 if ((v < INT_MIN || v > INT_MAX)) {
3397 return SWIG_OverflowError;
3398 } else {
3399 if (val) *val = (int)(v);
3400 }
3401 }
3402 return res;
3403}
3404
3405
3406SWIGINTERN int
3407SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3408{
3409#if PY_VERSION_HEX < 0x03000000
3410 if (PyInt_Check(obj)) {
3411 long v = PyInt_AsLong(obj);
3412 if (v >= 0) {
3413 if (val) *val = v;
3414 return SWIG_OK;
3415 } else {
3416 return SWIG_OverflowError;
3417 }
3418 } else
3419#endif
3420 if (PyLong_Check(obj)) {
3421 unsigned long v = PyLong_AsUnsignedLong(obj);
3422 if (!PyErr_Occurred()) {
3423 if (val) *val = v;
3424 return SWIG_OK;
3425 } else {
3426 PyErr_Clear();
3427 return SWIG_OverflowError;
3428 }
3429 }
3430#ifdef SWIG_PYTHON_CAST_MODE
3431 {
3432 int dispatch = 0;
3433 unsigned long v = PyLong_AsUnsignedLong(obj);
3434 if (!PyErr_Occurred()) {
3435 if (val) *val = v;
3436 return SWIG_AddCast(SWIG_OK);
3437 } else {
3438 PyErr_Clear();
3439 }
3440 if (!dispatch) {
3441 double d;
3442 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3443 // Largest double not larger than ULONG_MAX (not portably calculated easily)
3444 // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
3445 // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
3446 const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
3447 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
3448 if (val) *val = (unsigned long)(d);
3449 return res;
3450 }
3451 }
3452 }
3453#endif
3454 return SWIG_TypeError;
3455}
3456
3457
3458SWIGINTERN int
3459SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3460{
3461 unsigned long v;
3462 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3463 if (SWIG_IsOK(res)) {
3464 if ((v > UINT_MAX)) {
3465 return SWIG_OverflowError;
3466 } else {
3467 if (val) *val = (unsigned int)(v);
3468 }
3469 }
3470 return res;
3471}
3472
3473
3474SWIGINTERNINLINE PyObject*
3476{
3477 return PyInt_FromSize_t((size_t) value);
3478}
3479
3480
3483{
3484 static int init = 0;
3485 static swig_type_info* info = 0;
3486 if (!init) {
3487 info = SWIG_TypeQuery("_p_char");
3488 init = 1;
3489 }
3490 return info;
3491}
3492
3493
3494/* Return string from Python obj. NOTE: obj must remain in scope in order
3495 to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
3496SWIGINTERN int
3497SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
3498{
3499#if PY_VERSION_HEX>=0x03000000
3500#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3501 if (PyBytes_Check(obj))
3502#else
3503 if (PyUnicode_Check(obj))
3504#endif
3505#else
3506 if (PyString_Check(obj))
3507#endif
3508 {
3509 char *cstr; Py_ssize_t len;
3510 PyObject *bytes = NULL;
3511 int ret = SWIG_OK;
3512 if (alloc)
3513 *alloc = SWIG_OLDOBJ;
3514#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3515 if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
3516 return SWIG_TypeError;
3517#else
3518 cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
3519 if (!cstr)
3520 return SWIG_TypeError;
3521 /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
3522 if (bytes && cptr) {
3523 if (alloc) {
3524 cstr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3525 *alloc = SWIG_NEWOBJ;
3526 } else {
3527 /* alloc must be set in order to clean up allocated memory */
3528 return SWIG_RuntimeError;
3529 }
3530 }
3531#endif
3532 if (cptr) *cptr = cstr;
3533 if (psize) *psize = len + 1;
3534 Py_XDECREF(bytes);
3535 return ret;
3536 } else {
3537#if defined(SWIG_PYTHON_2_UNICODE)
3538#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3539#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3540#endif
3541#if PY_VERSION_HEX<0x03000000
3542 if (PyUnicode_Check(obj)) {
3543 char *cstr; Py_ssize_t len;
3544 if (!alloc && cptr) {
3545 return SWIG_RuntimeError;
3546 }
3547 obj = PyUnicode_AsUTF8String(obj);
3548 if (!obj)
3549 return SWIG_TypeError;
3550 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3551 if (cptr) {
3552 if (alloc) *alloc = SWIG_NEWOBJ;
3553 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3554 }
3555 if (psize) *psize = len + 1;
3556
3557 Py_XDECREF(obj);
3558 return SWIG_OK;
3559 } else {
3560 Py_XDECREF(obj);
3561 }
3562 }
3563#endif
3564#endif
3565
3566 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3567 if (pchar_descriptor) {
3568 void* vptr = 0;
3569 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3570 if (cptr) *cptr = (char *) vptr;
3571 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3572 if (alloc) *alloc = SWIG_OLDOBJ;
3573 return SWIG_OK;
3574 }
3575 }
3576 }
3577 return SWIG_TypeError;
3578}
3579
3580
3581SWIGINTERN int
3582SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3583{
3584 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3585 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3586 if (SWIG_IsOK(res)) {
3587 /* special case of single char conversion when we don't need space for NUL */
3588 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3589 if (csize <= size) {
3590 if (val) {
3591 if (csize) memcpy(val, cptr, csize*sizeof(char));
3592 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3593 }
3594 if (alloc == SWIG_NEWOBJ) {
3595 free((char*)cptr);
3596 res = SWIG_DelNewMask(res);
3597 }
3598 return res;
3599 }
3600 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3601 }
3602 return SWIG_TypeError;
3603}
3604
3605
3606SWIGINTERNINLINE PyObject *
3607SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3608{
3609 if (carray) {
3610 if (size > INT_MAX) {
3611 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3612 return pchar_descriptor ?
3613 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3614 } else {
3615#if PY_VERSION_HEX >= 0x03000000
3616#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3617 return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3618#else
3619 return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3620#endif
3621#else
3622 return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3623#endif
3624 }
3625 } else {
3626 return SWIG_Py_Void();
3627 }
3628}
3629
3630
3631SWIGINTERN size_t
3632SWIG_strnlen(const char* s, size_t maxlen)
3633{
3634 const char *p;
3635 for (p = s; maxlen-- && *p; p++)
3636 ;
3637 return p - s;
3638}
3639
3640
3641
3642
3643
3644#define t_output_helper SWIG_Python_AppendOutput
3645
3646
3647SWIGINTERN int
3648SWIG_AsVal_char (PyObject * obj, char *val)
3649{
3650 int res = SWIG_AsCharArray(obj, val, 1);
3651 if (!SWIG_IsOK(res)) {
3652 long v;
3653 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3654 if (SWIG_IsOK(res)) {
3655 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3656 if (val) *val = (char)(v);
3657 } else {
3658 res = SWIG_OverflowError;
3659 }
3660 }
3661 }
3662 return res;
3663}
3664
3665#ifdef __cplusplus
3666extern "C" {
3667#endif
3668
3669 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3670
3671// some really twisted stuff to allow calling a single precision library from python
3672 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3673 {
3674 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3675 mindims, maxdims );
3676 if ( !tmp )
3677 {
3678 // could be an incoming long array which can't be "safely" converted, do it anyway
3679 if ( PyArray_Check( in ) )
3680 {
3681 PyErr_Clear();
3682 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3683 }
3684 }
3685 return tmp;
3686 }
3687
3688
3689#define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3690
3691SWIGINTERN PyObject *_wrap_pltr0(PyObject *self, PyObject *args) {
3692 PyObject *resultobj = 0;
3693 PLFLT arg1 ;
3694 PLFLT arg2 ;
3695 PLFLT *arg3 = (PLFLT *) 0 ;
3696 PLFLT *arg4 = (PLFLT *) 0 ;
3697 PLPointer arg5 = (PLPointer) 0 ;
3698 double val1 ;
3699 int ecode1 = 0 ;
3700 double val2 ;
3701 int ecode2 = 0 ;
3702 PLFLT temp3 ;
3703 int res3 = SWIG_TMPOBJ ;
3704 PLFLT temp4 ;
3705 int res4 = SWIG_TMPOBJ ;
3706 PyObject *swig_obj[2] ;
3707
3708 arg3 = &temp3;
3709 arg4 = &temp4;
3710 {
3711 arg5 = NULL;
3712 }
3713 (void)self;
3714 if (!SWIG_Python_UnpackTuple(args, "pltr0", 2, 2, swig_obj)) SWIG_fail;
3715 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3716 if (!SWIG_IsOK(ecode1)) {
3717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3718 }
3719 arg1 = (PLFLT)(val1);
3720 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3721 if (!SWIG_IsOK(ecode2)) {
3722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3723 }
3724 arg2 = (PLFLT)(val2);
3725 pltr0(arg1,arg2,arg3,arg4,arg5);
3726 resultobj = SWIG_Py_Void();
3727 if (SWIG_IsTmpObj(res3)) {
3728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3729 } else {
3730 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3732 }
3733 if (SWIG_IsTmpObj(res4)) {
3734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3735 } else {
3736 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3738 }
3739 return resultobj;
3740fail:
3741 return NULL;
3742}
3743
3744
3745
3746 PyArrayObject *pltr_xg, *pltr_yg;
3749
3750 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3751 void cleanup_PLcGrid1( void );
3752 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3753 void cleanup_PLcGrid2( void );
3754
3755 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3756 {
3757 // fprintf(stderr, "marshal PLcGrid1\n");
3758 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3759 {
3760 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3761 return NULL;
3762 }
3763 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3764 NPY_PLFLT, 1, 1 );
3765 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3766 NPY_PLFLT, 1, 1 );
3767 if ( pltr_xg == 0 || pltr_yg == 0 )
3768 {
3769 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3770 return NULL;
3771 }
3772 tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3773 tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3774 if ( isimg == 0 )
3775 {
3776 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3777 {
3778 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3779 return NULL;
3780 }
3781 }
3782 else
3783 {
3784 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3785 {
3786 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3787 return NULL;
3788 }
3789 }
3790 tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3791 tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3792 return &tmpGrid1;
3793 }
3794
3795 void cleanup_PLcGrid1( void )
3796 {
3797 // fprintf(stderr, "cleanup PLcGrid1\n");
3798 Py_CLEAR( pltr_xg );
3799 Py_CLEAR( pltr_yg );
3800 }
3801
3802 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3803 {
3804 int i, size;
3805 // fprintf(stderr, "marshal PLcGrid2\n");
3806 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3807 {
3808 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3809 return NULL;
3810 }
3811 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3812 NPY_PLFLT, 2, 2 );
3813 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3814 NPY_PLFLT, 2, 2 );
3815 if ( pltr_xg == 0 || pltr_yg == 0 )
3816 {
3817 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3818 return NULL;
3819 }
3820 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3821 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3822 {
3823 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3824 return NULL;
3825 }
3826 tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3827 tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3828 if ( isimg == 0 )
3829 {
3830 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3831 {
3832 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3833 return NULL;
3834 }
3835 }
3836 else
3837 {
3838 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3839 {
3840 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3841 return NULL;
3842 }
3843 }
3844 size = tmpGrid2.ny;
3845 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3846 for ( i = 0; i < tmpGrid2.nx; i++ )
3847 tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3848 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3849 for ( i = 0; i < tmpGrid2.nx; i++ )
3850 tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3851 return &tmpGrid2;
3852 }
3853
3854 void cleanup_PLcGrid2( void )
3855 {
3856 // fprintf(stderr, "cleanup PLcGrid2\n");
3857 free( tmpGrid2.xg );
3858 free( tmpGrid2.yg );
3859 Py_CLEAR( pltr_xg );
3860 Py_CLEAR( pltr_yg );
3861 }
3862
3863SWIGINTERN PyObject *_wrap_pltr1(PyObject *self, PyObject *args) {
3864 PyObject *resultobj = 0;
3865 PLFLT arg1 ;
3866 PLFLT arg2 ;
3867 PLFLT *arg3 = (PLFLT *) 0 ;
3868 PLFLT *arg4 = (PLFLT *) 0 ;
3869 PLcGrid *arg5 = (PLcGrid *) 0 ;
3870 double val1 ;
3871 int ecode1 = 0 ;
3872 double val2 ;
3873 int ecode2 = 0 ;
3874 PLFLT temp3 ;
3875 int res3 = SWIG_TMPOBJ ;
3876 PLFLT temp4 ;
3877 int res4 = SWIG_TMPOBJ ;
3878 PyObject *swig_obj[3] ;
3879
3880 arg3 = &temp3;
3881 arg4 = &temp4;
3882 (void)self;
3883 if (!SWIG_Python_UnpackTuple(args, "pltr1", 3, 3, swig_obj)) SWIG_fail;
3884 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3885 if (!SWIG_IsOK(ecode1)) {
3886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3887 }
3888 arg1 = (PLFLT)(val1);
3889 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3890 if (!SWIG_IsOK(ecode2)) {
3891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3892 }
3893 arg2 = (PLFLT)(val2);
3894 {
3895 arg5 = marshal_PLcGrid1( swig_obj[2], 0 );
3896 if ( !arg5 )
3897 return NULL;
3898 }
3899 pltr1(arg1,arg2,arg3,arg4,arg5);
3900 resultobj = SWIG_Py_Void();
3901 if (SWIG_IsTmpObj(res3)) {
3902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3903 } else {
3904 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3906 }
3907 if (SWIG_IsTmpObj(res4)) {
3908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3909 } else {
3910 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3912 }
3913 {
3915 }
3916 return resultobj;
3917fail:
3918 {
3920 }
3921 return NULL;
3922}
3923
3924
3925SWIGINTERN PyObject *_wrap_pltr2(PyObject *self, PyObject *args) {
3926 PyObject *resultobj = 0;
3927 PLFLT arg1 ;
3928 PLFLT arg2 ;
3929 PLFLT *arg3 = (PLFLT *) 0 ;
3930 PLFLT *arg4 = (PLFLT *) 0 ;
3931 PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3932 double val1 ;
3933 int ecode1 = 0 ;
3934 double val2 ;
3935 int ecode2 = 0 ;
3936 PLFLT temp3 ;
3937 int res3 = SWIG_TMPOBJ ;
3938 PLFLT temp4 ;
3939 int res4 = SWIG_TMPOBJ ;
3940 PyObject *swig_obj[3] ;
3941
3942 arg3 = &temp3;
3943 arg4 = &temp4;
3944 (void)self;
3945 if (!SWIG_Python_UnpackTuple(args, "pltr2", 3, 3, swig_obj)) SWIG_fail;
3946 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3947 if (!SWIG_IsOK(ecode1)) {
3948 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3949 }
3950 arg1 = (PLFLT)(val1);
3951 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3952 if (!SWIG_IsOK(ecode2)) {
3953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3954 }
3955 arg2 = (PLFLT)(val2);
3956 {
3957 arg5 = marshal_PLcGrid2( swig_obj[2], 0 );
3958 if ( !arg5 )
3959 return NULL;
3960 }
3961 pltr2(arg1,arg2,arg3,arg4,arg5);
3962 resultobj = SWIG_Py_Void();
3963 if (SWIG_IsTmpObj(res3)) {
3964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3965 } else {
3966 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3968 }
3969 if (SWIG_IsTmpObj(res4)) {
3970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3971 } else {
3972 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3974 }
3975 {
3977 }
3978 return resultobj;
3979fail:
3980 {
3982 }
3983 return NULL;
3984}
3985
3986
3987
3988 // helper code for handling the callback
3989#if 0
3990 static PyInterpreterState *save_interp = NULL;
3991#endif
3993 PyObject* python_pltr = NULL;
3994 PyObject* python_f2eval = NULL;
3995 PyObject* python_ct = NULL;
3996 PyObject* python_mapform = NULL;
3997 PyObject* python_label = NULL;
3998
3999#if 0
4000#define MY_BLOCK_THREADS { \
4001 PyThreadState *prev_state, *new_state; \
4002 /* need to have started a thread at some stage */ \
4003 /* for the following to work */ \
4004 PyEval_AcquireLock(); \
4005 new_state = PyThreadState_New( save_interp ); \
4006 prev_state = PyThreadState_Swap( new_state );
4007#define MY_UNBLOCK_THREADS \
4008 new_state = PyThreadState_Swap( prev_state ); \
4009 PyThreadState_Clear( new_state ); \
4010 PyEval_ReleaseLock(); \
4011 PyThreadState_Delete( new_state ); \
4012 }
4013#else
4014#define MY_BLOCK_THREADS
4015#define MY_UNBLOCK_THREADS
4016#endif
4017
4018// Function prototypes
4019 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
4021 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
4022 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
4023 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
4024 pltr_func marshal_pltr( PyObject* input );
4025 void cleanup_pltr( void );
4026 ct_func marshal_ct( PyObject* input );
4027 void cleanup_ct( void );
4028 mapform_func marshal_mapform( PyObject* input );
4029 void cleanup_mapform( void );
4030 PLPointer marshal_PLPointer( PyObject* input, int isimg );
4031 void cleanup_PLPointer( void );
4032
4033
4034// This is the callback that gets handed to the C code. It, in turn, calls the Python callback
4035
4036 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
4037 {
4038 PyObject *pdata, *arglist, *result;
4039 PyArrayObject *tmp;
4040
4041 // the data argument is acutally a pointer to a python object
4042 pdata = (PyObject *) data;
4043 if ( data == NULL )
4044 {
4045 pdata = Py_None;
4046 }
4047 if ( python_pltr ) // if not something is terribly wrong
4048 { // hold a reference to the data object
4049 Py_XINCREF( pdata );
4050 // grab the Global Interpreter Lock to be sure threads don't mess us up
4052 // build the argument list
4053#ifdef PL_DOUBLE
4054 arglist = Py_BuildValue( "(ddO)", x, y, pdata );
4055#else
4056 arglist = Py_BuildValue( "(ffO)", x, y, pdata );
4057#endif
4058 if ( arglist == NULL )
4059 {
4060 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
4061 *tx = *ty = 0;
4062 return;
4063 }
4064 // call the python function
4065 result = PyObject_CallObject( python_pltr, arglist );
4066 // release the argument list
4067 Py_CLEAR( arglist );
4068 // check and unpack the result
4069 if ( result == NULL )
4070 {
4071 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
4072 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
4073 *tx = *ty = 0;
4074 }
4075 else
4076 {
4077 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
4078 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
4079 {
4080 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
4081 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
4082 *tx = *ty = 0;
4083 }
4084 else
4085 {
4086 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
4087 *tx = t[0];
4088 *ty = t[1];
4089 Py_CLEAR( tmp );
4090 }
4091 }
4092 // release the result
4093 Py_CLEAR( result );
4094 // release the global interpreter lock
4096 }
4097 }
4098
4100 {
4101 PyObject *pdata, *arglist, *result;
4102 PLFLT fresult = 0.0;
4103
4104 // the data argument is acutally a pointer to a python object
4105 pdata = (PyObject *) data;
4106 if ( python_f2eval ) // if not something is terribly wrong
4107 { // hold a reference to the data object
4108 Py_XINCREF( pdata );
4109 // grab the Global Interpreter Lock to be sure threads don't mess us up
4111 // build the argument list
4112 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
4113 // call the python function
4114 result = PyObject_CallObject( python_f2eval, arglist );
4115 // release the argument list
4116 Py_CLEAR( arglist );
4117 // check and unpack the result
4118 if ( !PyFloat_Check( result ) )
4119 {
4120 fprintf( stderr, "f2eval callback must return a float\n" );
4121 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
4122 }
4123 else
4124 {
4125 // should I test the type here?
4126 fresult = (PLFLT) PyFloat_AsDouble( result );
4127 }
4128 // release the result
4129 Py_CLEAR( result );
4130 // release the global interpreter lock
4132 }
4133 return fresult;
4134 }
4135
4136 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
4137 {
4138 PyObject *pdata, *arglist, *result, *unicode_string;
4139 char *pystring;
4140
4141 // the data argument is acutally a pointer to a python object
4142 if ( data )
4143 pdata = (PyObject *) data;
4144 else
4145 pdata = Py_None;
4146 if ( python_label ) // if not something is terribly wrong
4147 { // hold a reference to the data object
4148 Py_XINCREF( pdata );
4149 // grab the Global Interpreter Lock to be sure threads don't mess us up
4151 // build the argument list
4152#ifdef PL_DOUBLE
4153 arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
4154#else
4155 arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
4156#endif
4157 // call the python function
4158 result = PyObject_CallObject( python_label, arglist );
4159 // release the argument list
4160 //Py_CLEAR(arglist);
4161 // check and unpack the result
4162 if ( result == NULL )
4163 {
4164 fprintf( stderr, "label callback failed with 3 arguments\n" );
4165 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
4166 }
4167 else if ( PyString_Check( result ) )
4168 {
4169 // should I test the type here?
4170 pystring = PyString_AsString( result );
4171 strncpy( string, pystring, len );
4172 }
4173 else if ( PyUnicode_Check( result ) )
4174 {
4175 // unicode_string is never freed? memory leak here?
4176 unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
4177 pystring = PyBytes_AS_STRING( unicode_string );
4178 // len may be different then the byte string length w/ unicode?
4179 strncpy( string, pystring, len );
4180 }
4181 else
4182 {
4183 fprintf( stderr, "label callback must return a string\n" );
4184 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
4185 }
4186 // release the result
4187 Py_CLEAR( result );
4188 // release the global interpreter lock
4190 }
4191 }
4192
4193 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
4194 {
4195 PyObject *px, *py, *pdata, *arglist, *result;
4196 npy_intp n;
4197 n = 1;
4198
4199 // the data argument is acutally a pointer to a python object
4200 pdata = (PyObject *) data;
4201 if ( data == NULL )
4202 {
4203 pdata = Py_None;
4204 }
4205 if ( python_ct ) // if not something is terribly wrong
4206 { // hold a reference to the data object
4207 Py_XINCREF( pdata );
4208 // grab the Global Interpreter Lock to be sure threads don't mess us up
4210 // build the argument list
4211 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
4212 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
4213 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
4214 // call the python function
4215 result = PyObject_CallObject( python_ct, arglist );
4216 // release the argument list
4217 Py_CLEAR( arglist );
4218 Py_CLEAR( px );
4219 Py_CLEAR( py );
4220 Py_CLEAR( pdata );
4221 // check and unpack the result
4222 if ( result == NULL )
4223 {
4224 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
4225 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
4226 }
4227 // release the result
4228 Py_CLEAR( result );
4229 // release the global interpreter lock
4231 }
4232 }
4233
4235 {
4236 PyObject *px, *py, *arglist, *result;
4237 // PyArrayObject *tmpx, *tmpy;
4238// PLFLT *xx, *yy;
4239// PLINT i;
4240 npy_intp nn;
4241 nn = n;
4242
4243 if ( python_mapform ) // if not something is terribly wrong
4244 { // grab the Global Interpreter Lock to be sure threads don't mess us up
4246 // build the argument list
4247#ifdef PL_HAVE_PTHREAD
4248 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
4249 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
4250#else
4251 px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
4252 py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
4253#endif
4254 arglist = Py_BuildValue( "(iOO)", n, px, py );
4255 // call the python function
4256 result = PyObject_CallObject( python_mapform, arglist );
4257 // release the argument list
4258 Py_CLEAR( arglist );
4259 Py_CLEAR( px );
4260 Py_CLEAR( py );
4261 // check and unpack the result
4262 if ( result == NULL )
4263 {
4264 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
4265 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
4266 }
4267 // release the result
4268 Py_CLEAR( result );
4269 // release the global interpreter lock
4271 }
4272 }
4273
4274// marshal the pltr function pointer argument
4275 pltr_func marshal_pltr( PyObject* input )
4276 {
4277 pltr_func result = do_pltr_callback;
4278 PyObject * rep = PyObject_Repr( input );
4279 if ( rep )
4280 {
4281 // Memory leaks here? str and uni_str are not freed?
4282 char* str;
4283 if ( PyUnicode_Check( rep ) )
4284 {
4285 PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
4286 str = PyBytes_AS_STRING( uni_str );
4287 }
4288 else
4289 {
4290 str = PyString_AsString( rep );
4291 }
4292 if ( strstr( str, "function pltr0" ) != 0 )
4293 {
4294 result = pltr0;
4295 pltr_type = CB_0;
4296 python_pltr = NULL;
4297 }
4298 else if ( strstr( str, "function pltr1" ) != 0 )
4299 {
4300 result = pltr1;
4301 pltr_type = CB_1;
4302 python_pltr = NULL;
4303 }
4304 else if ( strstr( str, "function pltr2" ) != 0 )
4305 {
4306 result = pltr2;
4307 pltr_type = CB_2;
4308 python_pltr = NULL;
4309 }
4310 else
4311 {
4312 python_pltr = input;
4314 Py_XINCREF( input );
4315 }
4316 Py_CLEAR( rep );
4317 }
4318 else
4319 {
4320 python_pltr = input;
4322 Py_XINCREF( input );
4323 }
4324 return result;
4325 }
4326
4327 void cleanup_pltr( void )
4328 {
4329 Py_CLEAR( python_pltr );
4330 python_pltr = 0;
4331 }
4332
4333// marshal the ct function pointer argument
4334 ct_func marshal_ct( PyObject* input )
4335 {
4336 ct_func result = do_ct_callback;
4337 python_ct = input;
4338 Py_XINCREF( input );
4339 return result;
4340 }
4341
4342 void cleanup_ct( void )
4343 {
4344 Py_CLEAR( python_ct );
4345 python_ct = 0;
4346 }
4347
4348// marshal the mapform function pointer argument
4350 {
4352 python_mapform = input;
4353 Py_XINCREF( input );
4354 return result;
4355 }
4356
4357 void cleanup_mapform( void )
4358 {
4359 Py_CLEAR( python_mapform );
4360 python_mapform = 0;
4361 }
4362
4363 PLPointer marshal_PLPointer( PyObject* input, int isimg )
4364 {
4365 PLPointer result = NULL;
4366 switch ( pltr_type )
4367 {
4368 case CB_0:
4369 break;
4370 case CB_1:
4371 if ( input != Py_None )
4372 result = marshal_PLcGrid1( input, isimg );
4373 break;
4374 case CB_2:
4375 if ( input != Py_None )
4376 result = marshal_PLcGrid2( input, isimg );
4377 break;
4378 case CB_Python:
4379 Py_XINCREF( input );
4380 result = (PLPointer *) input;
4381 break;
4382 default:
4383 fprintf( stderr, "pltr_type is invalid\n" );
4384 }
4385 return result;
4386 }
4387
4389 {
4390 switch ( pltr_type )
4391 {
4392 case CB_0:
4393 break;
4394 case CB_1:
4396 break;
4397 case CB_2:
4399 break;
4400 case CB_Python:
4401 Py_CLEAR( python_pltr );
4402 break;
4403 default:
4404 fprintf( stderr, "pltr_type is invalid\n" );
4405 }
4406 python_pltr = 0;
4407 pltr_type = CB_0;
4408 }
4409
4410
4411
4412SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args) {
4413 PyObject *resultobj = 0;
4414 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4415 int arg2 ;
4416 void *argp1 = 0 ;
4417 int res1 = 0 ;
4418 int val2 ;
4419 int ecode2 = 0 ;
4420 PyObject *swig_obj[2] ;
4421
4422 (void)self;
4423 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_type_set", 2, 2, swig_obj)) SWIG_fail;
4424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4425 if (!SWIG_IsOK(res1)) {
4426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4427 }
4428 arg1 = (PLGraphicsIn *)(argp1);
4429 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4430 if (!SWIG_IsOK(ecode2)) {
4431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4432 }
4433 arg2 = (int)(val2);
4434 if (arg1) (arg1)->type = arg2;
4435 resultobj = SWIG_Py_Void();
4436 return resultobj;
4437fail:
4438 return NULL;
4439}
4440
4441
4442SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args) {
4443 PyObject *resultobj = 0;
4444 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4445 void *argp1 = 0 ;
4446 int res1 = 0 ;
4447 PyObject *swig_obj[1] ;
4448 int result;
4449
4450 (void)self;
4451 if (!args) SWIG_fail;
4452 swig_obj[0] = args;
4453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4454 if (!SWIG_IsOK(res1)) {
4455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4456 }
4457 arg1 = (PLGraphicsIn *)(argp1);
4458 result = (int) ((arg1)->type);
4459 resultobj = SWIG_From_int((int)(result));
4460 return resultobj;
4461fail:
4462 return NULL;
4463}
4464
4465
4466SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args) {
4467 PyObject *resultobj = 0;
4468 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4469 unsigned int arg2 ;
4470 void *argp1 = 0 ;
4471 int res1 = 0 ;
4472 unsigned int val2 ;
4473 int ecode2 = 0 ;
4474 PyObject *swig_obj[2] ;
4475
4476 (void)self;
4477 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_state_set", 2, 2, swig_obj)) SWIG_fail;
4478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4479 if (!SWIG_IsOK(res1)) {
4480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4481 }
4482 arg1 = (PLGraphicsIn *)(argp1);
4483 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4484 if (!SWIG_IsOK(ecode2)) {
4485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4486 }
4487 arg2 = (unsigned int)(val2);
4488 if (arg1) (arg1)->state = arg2;
4489 resultobj = SWIG_Py_Void();
4490 return resultobj;
4491fail:
4492 return NULL;
4493}
4494
4495
4496SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args) {
4497 PyObject *resultobj = 0;
4498 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4499 void *argp1 = 0 ;
4500 int res1 = 0 ;
4501 PyObject *swig_obj[1] ;
4502 unsigned int result;
4503
4504 (void)self;
4505 if (!args) SWIG_fail;
4506 swig_obj[0] = args;
4507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4508 if (!SWIG_IsOK(res1)) {
4509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4510 }
4511 arg1 = (PLGraphicsIn *)(argp1);
4512 result = (unsigned int) ((arg1)->state);
4513 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4514 return resultobj;
4515fail:
4516 return NULL;
4517}
4518
4519
4520SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args) {
4521 PyObject *resultobj = 0;
4522 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4523 unsigned int arg2 ;
4524 void *argp1 = 0 ;
4525 int res1 = 0 ;
4526 unsigned int val2 ;
4527 int ecode2 = 0 ;
4528 PyObject *swig_obj[2] ;
4529
4530 (void)self;
4531 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_keysym_set", 2, 2, swig_obj)) SWIG_fail;
4532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4533 if (!SWIG_IsOK(res1)) {
4534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4535 }
4536 arg1 = (PLGraphicsIn *)(argp1);
4537 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4538 if (!SWIG_IsOK(ecode2)) {
4539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4540 }
4541 arg2 = (unsigned int)(val2);
4542 if (arg1) (arg1)->keysym = arg2;
4543 resultobj = SWIG_Py_Void();
4544 return resultobj;
4545fail:
4546 return NULL;
4547}
4548
4549
4550SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args) {
4551 PyObject *resultobj = 0;
4552 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4553 void *argp1 = 0 ;
4554 int res1 = 0 ;
4555 PyObject *swig_obj[1] ;
4556 unsigned int result;
4557
4558 (void)self;
4559 if (!args) SWIG_fail;
4560 swig_obj[0] = args;
4561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4562 if (!SWIG_IsOK(res1)) {
4563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4564 }
4565 arg1 = (PLGraphicsIn *)(argp1);
4566 result = (unsigned int) ((arg1)->keysym);
4567 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4568 return resultobj;
4569fail:
4570 return NULL;
4571}
4572
4573
4574SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args) {
4575 PyObject *resultobj = 0;
4576 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4577 unsigned int arg2 ;
4578 void *argp1 = 0 ;
4579 int res1 = 0 ;
4580 unsigned int val2 ;
4581 int ecode2 = 0 ;
4582 PyObject *swig_obj[2] ;
4583
4584 (void)self;
4585 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_button_set", 2, 2, swig_obj)) SWIG_fail;
4586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4587 if (!SWIG_IsOK(res1)) {
4588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4589 }
4590 arg1 = (PLGraphicsIn *)(argp1);
4591 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4592 if (!SWIG_IsOK(ecode2)) {
4593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4594 }
4595 arg2 = (unsigned int)(val2);
4596 if (arg1) (arg1)->button = arg2;
4597 resultobj = SWIG_Py_Void();
4598 return resultobj;
4599fail:
4600 return NULL;
4601}
4602
4603
4604SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args) {
4605 PyObject *resultobj = 0;
4606 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4607 void *argp1 = 0 ;
4608 int res1 = 0 ;
4609 PyObject *swig_obj[1] ;
4610 unsigned int result;
4611
4612 (void)self;
4613 if (!args) SWIG_fail;
4614 swig_obj[0] = args;
4615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4616 if (!SWIG_IsOK(res1)) {
4617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4618 }
4619 arg1 = (PLGraphicsIn *)(argp1);
4620 result = (unsigned int) ((arg1)->button);
4621 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4622 return resultobj;
4623fail:
4624 return NULL;
4625}
4626
4627
4628SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args) {
4629 PyObject *resultobj = 0;
4630 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4631 PLINT arg2 ;
4632 void *argp1 = 0 ;
4633 int res1 = 0 ;
4634 int val2 ;
4635 int ecode2 = 0 ;
4636 PyObject *swig_obj[2] ;
4637
4638 (void)self;
4639 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_subwindow_set", 2, 2, swig_obj)) SWIG_fail;
4640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4641 if (!SWIG_IsOK(res1)) {
4642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4643 }
4644 arg1 = (PLGraphicsIn *)(argp1);
4645 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4646 if (!SWIG_IsOK(ecode2)) {
4647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4648 }
4649 arg2 = (PLINT)(val2);
4650 if (arg1) (arg1)->subwindow = arg2;
4651 resultobj = SWIG_Py_Void();
4652 return resultobj;
4653fail:
4654 return NULL;
4655}
4656
4657
4658SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args) {
4659 PyObject *resultobj = 0;
4660 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4661 void *argp1 = 0 ;
4662 int res1 = 0 ;
4663 PyObject *swig_obj[1] ;
4664 PLINT result;
4665
4666 (void)self;
4667 if (!args) SWIG_fail;
4668 swig_obj[0] = args;
4669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4670 if (!SWIG_IsOK(res1)) {
4671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4672 }
4673 arg1 = (PLGraphicsIn *)(argp1);
4674 result = (PLINT) ((arg1)->subwindow);
4675 resultobj = SWIG_From_int((int)(result));
4676 return resultobj;
4677fail:
4678 return NULL;
4679}
4680
4681
4682SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args) {
4683 PyObject *resultobj = 0;
4684 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4685 char *arg2 = (char *) (char *)0 ;
4686 void *argp1 = 0 ;
4687 int res1 = 0 ;
4688 char temp2[16] ;
4689 int res2 ;
4690 PyObject *swig_obj[2] ;
4691
4692 (void)self;
4693 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_string_set", 2, 2, swig_obj)) SWIG_fail;
4694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4695 if (!SWIG_IsOK(res1)) {
4696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4697 }
4698 arg1 = (PLGraphicsIn *)(argp1);
4699 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 16);
4700 if (!SWIG_IsOK(res2)) {
4701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4702 }
4703 arg2 = (char *)(temp2);
4704 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4705 else memset(arg1->string,0,16*sizeof(char));
4706 resultobj = SWIG_Py_Void();
4707 return resultobj;
4708fail:
4709 return NULL;
4710}
4711
4712
4713SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args) {
4714 PyObject *resultobj = 0;
4715 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4716 void *argp1 = 0 ;
4717 int res1 = 0 ;
4718 PyObject *swig_obj[1] ;
4719 char *result = 0 ;
4720
4721 (void)self;
4722 if (!args) SWIG_fail;
4723 swig_obj[0] = args;
4724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4725 if (!SWIG_IsOK(res1)) {
4726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4727 }
4728 arg1 = (PLGraphicsIn *)(argp1);
4729 result = (char *)(char *) ((arg1)->string);
4730 {
4731 size_t size = SWIG_strnlen(result, 16);
4732
4733
4734
4735 resultobj = SWIG_FromCharPtrAndSize(result, size);
4736 }
4737 return resultobj;
4738fail:
4739 return NULL;
4740}
4741
4742
4743SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args) {
4744 PyObject *resultobj = 0;
4745 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4746 int arg2 ;
4747 void *argp1 = 0 ;
4748 int res1 = 0 ;
4749 int val2 ;
4750 int ecode2 = 0 ;
4751 PyObject *swig_obj[2] ;
4752
4753 (void)self;
4754 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pX_set", 2, 2, swig_obj)) SWIG_fail;
4755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4756 if (!SWIG_IsOK(res1)) {
4757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4758 }
4759 arg1 = (PLGraphicsIn *)(argp1);
4760 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4761 if (!SWIG_IsOK(ecode2)) {
4762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4763 }
4764 arg2 = (int)(val2);
4765 if (arg1) (arg1)->pX = arg2;
4766 resultobj = SWIG_Py_Void();
4767 return resultobj;
4768fail:
4769 return NULL;
4770}
4771
4772
4773SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args) {
4774 PyObject *resultobj = 0;
4775 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4776 void *argp1 = 0 ;
4777 int res1 = 0 ;
4778 PyObject *swig_obj[1] ;
4779 int result;
4780
4781 (void)self;
4782 if (!args) SWIG_fail;
4783 swig_obj[0] = args;
4784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4785 if (!SWIG_IsOK(res1)) {
4786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4787 }
4788 arg1 = (PLGraphicsIn *)(argp1);
4789 result = (int) ((arg1)->pX);
4790 resultobj = SWIG_From_int((int)(result));
4791 return resultobj;
4792fail:
4793 return NULL;
4794}
4795
4796
4797SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args) {
4798 PyObject *resultobj = 0;
4799 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4800 int arg2 ;
4801 void *argp1 = 0 ;
4802 int res1 = 0 ;
4803 int val2 ;
4804 int ecode2 = 0 ;
4805 PyObject *swig_obj[2] ;
4806
4807 (void)self;
4808 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pY_set", 2, 2, swig_obj)) SWIG_fail;
4809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4810 if (!SWIG_IsOK(res1)) {
4811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4812 }
4813 arg1 = (PLGraphicsIn *)(argp1);
4814 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4815 if (!SWIG_IsOK(ecode2)) {
4816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4817 }
4818 arg2 = (int)(val2);
4819 if (arg1) (arg1)->pY = arg2;
4820 resultobj = SWIG_Py_Void();
4821 return resultobj;
4822fail:
4823 return NULL;
4824}
4825
4826
4827SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args) {
4828 PyObject *resultobj = 0;
4829 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4830 void *argp1 = 0 ;
4831 int res1 = 0 ;
4832 PyObject *swig_obj[1] ;
4833 int result;
4834
4835 (void)self;
4836 if (!args) SWIG_fail;
4837 swig_obj[0] = args;
4838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4839 if (!SWIG_IsOK(res1)) {
4840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4841 }
4842 arg1 = (PLGraphicsIn *)(argp1);
4843 result = (int) ((arg1)->pY);
4844 resultobj = SWIG_From_int((int)(result));
4845 return resultobj;
4846fail:
4847 return NULL;
4848}
4849
4850
4851SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args) {
4852 PyObject *resultobj = 0;
4853 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4854 PLFLT arg2 ;
4855 void *argp1 = 0 ;
4856 int res1 = 0 ;
4857 double val2 ;
4858 int ecode2 = 0 ;
4859 PyObject *swig_obj[2] ;
4860
4861 (void)self;
4862 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dX_set", 2, 2, swig_obj)) SWIG_fail;
4863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4864 if (!SWIG_IsOK(res1)) {
4865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4866 }
4867 arg1 = (PLGraphicsIn *)(argp1);
4868 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4869 if (!SWIG_IsOK(ecode2)) {
4870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4871 }
4872 arg2 = (PLFLT)(val2);
4873 if (arg1) (arg1)->dX = arg2;
4874 resultobj = SWIG_Py_Void();
4875 return resultobj;
4876fail:
4877 return NULL;
4878}
4879
4880
4881SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args) {
4882 PyObject *resultobj = 0;
4883 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4884 void *argp1 = 0 ;
4885 int res1 = 0 ;
4886 PyObject *swig_obj[1] ;
4887 PLFLT result;
4888
4889 (void)self;
4890 if (!args) SWIG_fail;
4891 swig_obj[0] = args;
4892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4893 if (!SWIG_IsOK(res1)) {
4894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4895 }
4896 arg1 = (PLGraphicsIn *)(argp1);
4897 result = (PLFLT) ((arg1)->dX);
4898 resultobj = SWIG_From_double((double)(result));
4899 return resultobj;
4900fail:
4901 return NULL;
4902}
4903
4904
4905SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args) {
4906 PyObject *resultobj = 0;
4907 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4908 PLFLT arg2 ;
4909 void *argp1 = 0 ;
4910 int res1 = 0 ;
4911 double val2 ;
4912 int ecode2 = 0 ;
4913 PyObject *swig_obj[2] ;
4914
4915 (void)self;
4916 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dY_set", 2, 2, swig_obj)) SWIG_fail;
4917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4918 if (!SWIG_IsOK(res1)) {
4919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4920 }
4921 arg1 = (PLGraphicsIn *)(argp1);
4922 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4923 if (!SWIG_IsOK(ecode2)) {
4924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4925 }
4926 arg2 = (PLFLT)(val2);
4927 if (arg1) (arg1)->dY = arg2;
4928 resultobj = SWIG_Py_Void();
4929 return resultobj;
4930fail:
4931 return NULL;
4932}
4933
4934
4935SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args) {
4936 PyObject *resultobj = 0;
4937 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4938 void *argp1 = 0 ;
4939 int res1 = 0 ;
4940 PyObject *swig_obj[1] ;
4941 PLFLT result;
4942
4943 (void)self;
4944 if (!args) SWIG_fail;
4945 swig_obj[0] = args;
4946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4947 if (!SWIG_IsOK(res1)) {
4948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4949 }
4950 arg1 = (PLGraphicsIn *)(argp1);
4951 result = (PLFLT) ((arg1)->dY);
4952 resultobj = SWIG_From_double((double)(result));
4953 return resultobj;
4954fail:
4955 return NULL;
4956}
4957
4958
4959SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args) {
4960 PyObject *resultobj = 0;
4961 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4962 PLFLT arg2 ;
4963 void *argp1 = 0 ;
4964 int res1 = 0 ;
4965 double val2 ;
4966 int ecode2 = 0 ;
4967 PyObject *swig_obj[2] ;
4968
4969 (void)self;
4970 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wX_set", 2, 2, swig_obj)) SWIG_fail;
4971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4972 if (!SWIG_IsOK(res1)) {
4973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4974 }
4975 arg1 = (PLGraphicsIn *)(argp1);
4976 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4977 if (!SWIG_IsOK(ecode2)) {
4978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4979 }
4980 arg2 = (PLFLT)(val2);
4981 if (arg1) (arg1)->wX = arg2;
4982 resultobj = SWIG_Py_Void();
4983 return resultobj;
4984fail:
4985 return NULL;
4986}
4987
4988
4989SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args) {
4990 PyObject *resultobj = 0;
4991 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4992 void *argp1 = 0 ;
4993 int res1 = 0 ;
4994 PyObject *swig_obj[1] ;
4995 PLFLT result;
4996
4997 (void)self;
4998 if (!args) SWIG_fail;
4999 swig_obj[0] = args;
5000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5001 if (!SWIG_IsOK(res1)) {
5002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5003 }
5004 arg1 = (PLGraphicsIn *)(argp1);
5005 result = (PLFLT) ((arg1)->wX);
5006 resultobj = SWIG_From_double((double)(result));
5007 return resultobj;
5008fail:
5009 return NULL;
5010}
5011
5012
5013SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args) {
5014 PyObject *resultobj = 0;
5015 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5016 PLFLT arg2 ;
5017 void *argp1 = 0 ;
5018 int res1 = 0 ;
5019 double val2 ;
5020 int ecode2 = 0 ;
5021 PyObject *swig_obj[2] ;
5022
5023 (void)self;
5024 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wY_set", 2, 2, swig_obj)) SWIG_fail;
5025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5026 if (!SWIG_IsOK(res1)) {
5027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5028 }
5029 arg1 = (PLGraphicsIn *)(argp1);
5030 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5031 if (!SWIG_IsOK(ecode2)) {
5032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
5033 }
5034 arg2 = (PLFLT)(val2);
5035 if (arg1) (arg1)->wY = arg2;
5036 resultobj = SWIG_Py_Void();
5037 return resultobj;
5038fail:
5039 return NULL;
5040}
5041
5042
5043SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args) {
5044 PyObject *resultobj = 0;
5045 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5046 void *argp1 = 0 ;
5047 int res1 = 0 ;
5048 PyObject *swig_obj[1] ;
5049 PLFLT result;
5050
5051 (void)self;
5052 if (!args) SWIG_fail;
5053 swig_obj[0] = args;
5054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5055 if (!SWIG_IsOK(res1)) {
5056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5057 }
5058 arg1 = (PLGraphicsIn *)(argp1);
5059 result = (PLFLT) ((arg1)->wY);
5060 resultobj = SWIG_From_double((double)(result));
5061 return resultobj;
5062fail:
5063 return NULL;
5064}
5065
5066
5067SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *self, PyObject *args) {
5068 PyObject *resultobj = 0;
5069 PLGraphicsIn *result = 0 ;
5070
5071 (void)self;
5072 if (!SWIG_Python_UnpackTuple(args, "new_PLGraphicsIn", 0, 0, 0)) SWIG_fail;
5073 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
5075 return resultobj;
5076fail:
5077 return NULL;
5078}
5079
5080
5081SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args) {
5082 PyObject *resultobj = 0;
5083 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5084 void *argp1 = 0 ;
5085 int res1 = 0 ;
5086 PyObject *swig_obj[1] ;
5087
5088 (void)self;
5089 if (!args) SWIG_fail;
5090 swig_obj[0] = args;
5091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
5092 if (!SWIG_IsOK(res1)) {
5093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5094 }
5095 arg1 = (PLGraphicsIn *)(argp1);
5096 free((char *) arg1);
5097 resultobj = SWIG_Py_Void();
5098 return resultobj;
5099fail:
5100 return NULL;
5101}
5102
5103
5104SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5105 PyObject *obj;
5106 if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
5108 return SWIG_Py_Void();
5109}
5110
5111SWIGINTERN PyObject *PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5112 return SWIG_Python_InitShadowInstance(args);
5113}
5114
5115SWIGINTERN PyObject *_wrap_plsxwin(PyObject *self, PyObject *args) {
5116 PyObject *resultobj = 0;
5117 PLINT arg1 ;
5118 int val1 ;
5119 int ecode1 = 0 ;
5120 PyObject *swig_obj[1] ;
5121
5122 (void)self;
5123 if (!args) SWIG_fail;
5124 swig_obj[0] = args;
5125 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5126 if (!SWIG_IsOK(ecode1)) {
5127 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
5128 }
5129 arg1 = (PLINT)(val1);
5130 plsxwin(arg1);
5131 resultobj = SWIG_Py_Void();
5132 return resultobj;
5133fail:
5134 return NULL;
5135}
5136
5137
5138SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *self, PyObject *args) {
5139 PyObject *resultobj = 0;
5140 PLINT arg1 ;
5141 PLINT arg2 ;
5142 int val1 ;
5143 int ecode1 = 0 ;
5144 int val2 ;
5145 int ecode2 = 0 ;
5146 PyObject *swig_obj[2] ;
5147
5148 (void)self;
5149 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelformat", 2, 2, swig_obj)) SWIG_fail;
5150 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5151 if (!SWIG_IsOK(ecode1)) {
5152 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
5153 }
5154 arg1 = (PLINT)(val1);
5155 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5156 if (!SWIG_IsOK(ecode2)) {
5157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
5158 }
5159 arg2 = (PLINT)(val2);
5160 pl_setcontlabelformat(arg1,arg2);
5161 resultobj = SWIG_Py_Void();
5162 return resultobj;
5163fail:
5164 return NULL;
5165}
5166
5167
5168SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *self, PyObject *args) {
5169 PyObject *resultobj = 0;
5170 PLFLT arg1 ;
5171 PLFLT arg2 ;
5172 PLFLT arg3 ;
5173 PLINT arg4 ;
5174 double val1 ;
5175 int ecode1 = 0 ;
5176 double val2 ;
5177 int ecode2 = 0 ;
5178 double val3 ;
5179 int ecode3 = 0 ;
5180 int val4 ;
5181 int ecode4 = 0 ;
5182 PyObject *swig_obj[4] ;
5183
5184 (void)self;
5185 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelparam", 4, 4, swig_obj)) SWIG_fail;
5186 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5187 if (!SWIG_IsOK(ecode1)) {
5188 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
5189 }
5190 arg1 = (PLFLT)(val1);
5191 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5192 if (!SWIG_IsOK(ecode2)) {
5193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
5194 }
5195 arg2 = (PLFLT)(val2);
5196 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5197 if (!SWIG_IsOK(ecode3)) {
5198 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
5199 }
5200 arg3 = (PLFLT)(val3);
5201 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5202 if (!SWIG_IsOK(ecode4)) {
5203 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
5204 }
5205 arg4 = (PLINT)(val4);
5206 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
5207 resultobj = SWIG_Py_Void();
5208 return resultobj;
5209fail:
5210 return NULL;
5211}
5212
5213
5214SWIGINTERN PyObject *_wrap_pladv(PyObject *self, PyObject *args) {
5215 PyObject *resultobj = 0;
5216 PLINT arg1 ;
5217 int val1 ;
5218 int ecode1 = 0 ;
5219 PyObject *swig_obj[1] ;
5220
5221 (void)self;
5222 if (!args) SWIG_fail;
5223 swig_obj[0] = args;
5224 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5225 if (!SWIG_IsOK(ecode1)) {
5226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
5227 }
5228 arg1 = (PLINT)(val1);
5229 pladv(arg1);
5230 resultobj = SWIG_Py_Void();
5231 return resultobj;
5232fail:
5233 return NULL;
5234}
5235
5236
5237SWIGINTERN PyObject *_wrap_plarc(PyObject *self, PyObject *args) {
5238 PyObject *resultobj = 0;
5239 PLFLT arg1 ;
5240 PLFLT arg2 ;
5241 PLFLT arg3 ;
5242 PLFLT arg4 ;
5243 PLFLT arg5 ;
5244 PLFLT arg6 ;
5245 PLFLT arg7 ;
5246 PLBOOL arg8 ;
5247 double val1 ;
5248 int ecode1 = 0 ;
5249 double val2 ;
5250 int ecode2 = 0 ;
5251 double val3 ;
5252 int ecode3 = 0 ;
5253 double val4 ;
5254 int ecode4 = 0 ;
5255 double val5 ;
5256 int ecode5 = 0 ;
5257 double val6 ;
5258 int ecode6 = 0 ;
5259 double val7 ;
5260 int ecode7 = 0 ;
5261 int val8 ;
5262 int ecode8 = 0 ;
5263 PyObject *swig_obj[8] ;
5264
5265 (void)self;
5266 if (!SWIG_Python_UnpackTuple(args, "plarc", 8, 8, swig_obj)) SWIG_fail;
5267 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5268 if (!SWIG_IsOK(ecode1)) {
5269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
5270 }
5271 arg1 = (PLFLT)(val1);
5272 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5273 if (!SWIG_IsOK(ecode2)) {
5274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
5275 }
5276 arg2 = (PLFLT)(val2);
5277 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5278 if (!SWIG_IsOK(ecode3)) {
5279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
5280 }
5281 arg3 = (PLFLT)(val3);
5282 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5283 if (!SWIG_IsOK(ecode4)) {
5284 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
5285 }
5286 arg4 = (PLFLT)(val4);
5287 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5288 if (!SWIG_IsOK(ecode5)) {
5289 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
5290 }
5291 arg5 = (PLFLT)(val5);
5292 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5293 if (!SWIG_IsOK(ecode6)) {
5294 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
5295 }
5296 arg6 = (PLFLT)(val6);
5297 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5298 if (!SWIG_IsOK(ecode7)) {
5299 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
5300 }
5301 arg7 = (PLFLT)(val7);
5302 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5303 if (!SWIG_IsOK(ecode8)) {
5304 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
5305 }
5306 arg8 = (PLBOOL)(val8);
5307 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5308 resultobj = SWIG_Py_Void();
5309 return resultobj;
5310fail:
5311 return NULL;
5312}
5313
5314
5315SWIGINTERN PyObject *_wrap_plaxes(PyObject *self, PyObject *args) {
5316 PyObject *resultobj = 0;
5317 PLFLT arg1 ;
5318 PLFLT arg2 ;
5319 char *arg3 = (char *) 0 ;
5320 PLFLT arg4 ;
5321 PLINT arg5 ;
5322 char *arg6 = (char *) 0 ;
5323 PLFLT arg7 ;
5324 PLINT arg8 ;
5325 double val1 ;
5326 int ecode1 = 0 ;
5327 double val2 ;
5328 int ecode2 = 0 ;
5329 int res3 ;
5330 char *buf3 = 0 ;
5331 int alloc3 = 0 ;
5332 double val4 ;
5333 int ecode4 = 0 ;
5334 int val5 ;
5335 int ecode5 = 0 ;
5336 int res6 ;
5337 char *buf6 = 0 ;
5338 int alloc6 = 0 ;
5339 double val7 ;
5340 int ecode7 = 0 ;
5341 int val8 ;
5342 int ecode8 = 0 ;
5343 PyObject *swig_obj[8] ;
5344
5345 (void)self;
5346 if (!SWIG_Python_UnpackTuple(args, "plaxes", 8, 8, swig_obj)) SWIG_fail;
5347 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5348 if (!SWIG_IsOK(ecode1)) {
5349 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5350 }
5351 arg1 = (PLFLT)(val1);
5352 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5353 if (!SWIG_IsOK(ecode2)) {
5354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5355 }
5356 arg2 = (PLFLT)(val2);
5357 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
5358 if (!SWIG_IsOK(res3)) {
5359 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5360 }
5361 arg3 = (char *)(buf3);
5362 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5363 if (!SWIG_IsOK(ecode4)) {
5364 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5365 }
5366 arg4 = (PLFLT)(val4);
5367 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5368 if (!SWIG_IsOK(ecode5)) {
5369 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5370 }
5371 arg5 = (PLINT)(val5);
5372 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5373 if (!SWIG_IsOK(res6)) {
5374 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5375 }
5376 arg6 = (char *)(buf6);
5377 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5378 if (!SWIG_IsOK(ecode7)) {
5379 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5380 }
5381 arg7 = (PLFLT)(val7);
5382 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5383 if (!SWIG_IsOK(ecode8)) {
5384 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5385 }
5386 arg8 = (PLINT)(val8);
5387 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5388 resultobj = SWIG_Py_Void();
5389 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5390 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5391 return resultobj;
5392fail:
5393 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5394 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5395 return NULL;
5396}
5397
5398
5399SWIGINTERN PyObject *_wrap_plbin(PyObject *self, PyObject *args) {
5400 PyObject *resultobj = 0;
5401 PLINT arg1 ;
5402 PLFLT *arg2 = (PLFLT *) 0 ;
5403 PLFLT *arg3 = (PLFLT *) 0 ;
5404 PLINT arg4 ;
5405 PyArrayObject *tmp1 = NULL ;
5406 PyArrayObject *tmp3 = NULL ;
5407 int val4 ;
5408 int ecode4 = 0 ;
5409 PyObject *swig_obj[3] ;
5410
5411 (void)self;
5412 if (!SWIG_Python_UnpackTuple(args, "plbin", 3, 3, swig_obj)) SWIG_fail;
5413 {
5414 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5415 if ( tmp1 == NULL )
5416 return NULL;
5417 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5418 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5419 }
5420 {
5421 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5422 if ( tmp3 == NULL )
5423 return NULL;
5424 if ( PyArray_DIMS( tmp3 )[0] != Alen )
5425 {
5426 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5427 return NULL;
5428 }
5429 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5430 }
5431 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
5432 if (!SWIG_IsOK(ecode4)) {
5433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5434 }
5435 arg4 = (PLINT)(val4);
5436 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5437 resultobj = SWIG_Py_Void();
5438 {
5439 Py_CLEAR( tmp1 );
5440 }
5441 {
5442 Py_CLEAR( tmp3 );
5443 }
5444 return resultobj;
5445fail:
5446 {
5447 Py_CLEAR( tmp1 );
5448 }
5449 {
5450 Py_CLEAR( tmp3 );
5451 }
5452 return NULL;
5453}
5454
5455
5456SWIGINTERN PyObject *_wrap_plbtime(PyObject *self, PyObject *args) {
5457 PyObject *resultobj = 0;
5458 PLINT *arg1 = (PLINT *) 0 ;
5459 PLINT *arg2 = (PLINT *) 0 ;
5460 PLINT *arg3 = (PLINT *) 0 ;
5461 PLINT *arg4 = (PLINT *) 0 ;
5462 PLINT *arg5 = (PLINT *) 0 ;
5463 PLFLT *arg6 = (PLFLT *) 0 ;
5464 PLFLT arg7 ;
5465 PLINT temp1 ;
5466 int res1 = SWIG_TMPOBJ ;
5467 PLINT temp2 ;
5468 int res2 = SWIG_TMPOBJ ;
5469 PLINT temp3 ;
5470 int res3 = SWIG_TMPOBJ ;
5471 PLINT temp4 ;
5472 int res4 = SWIG_TMPOBJ ;
5473 PLINT temp5 ;
5474 int res5 = SWIG_TMPOBJ ;
5475 PLFLT temp6 ;
5476 int res6 = SWIG_TMPOBJ ;
5477 double val7 ;
5478 int ecode7 = 0 ;
5479 PyObject *swig_obj[1] ;
5480
5481 arg1 = &temp1;
5482 arg2 = &temp2;
5483 arg3 = &temp3;
5484 arg4 = &temp4;
5485 arg5 = &temp5;
5486 arg6 = &temp6;
5487 (void)self;
5488 if (!args) SWIG_fail;
5489 swig_obj[0] = args;
5490 ecode7 = SWIG_AsVal_double(swig_obj[0], &val7);
5491 if (!SWIG_IsOK(ecode7)) {
5492 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5493 }
5494 arg7 = (PLFLT)(val7);
5495 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5496 resultobj = SWIG_Py_Void();
5497 if (SWIG_IsTmpObj(res1)) {
5498 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5499 } else {
5500 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5501 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5502 }
5503 if (SWIG_IsTmpObj(res2)) {
5504 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5505 } else {
5506 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5507 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5508 }
5509 if (SWIG_IsTmpObj(res3)) {
5510 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
5511 } else {
5512 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5513 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
5514 }
5515 if (SWIG_IsTmpObj(res4)) {
5516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5517 } else {
5518 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5520 }
5521 if (SWIG_IsTmpObj(res5)) {
5522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5523 } else {
5524 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5526 }
5527 if (SWIG_IsTmpObj(res6)) {
5528 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5529 } else {
5530 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5531 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5532 }
5533 return resultobj;
5534fail:
5535 return NULL;
5536}
5537
5538
5539SWIGINTERN PyObject *_wrap_plbop(PyObject *self, PyObject *args) {
5540 PyObject *resultobj = 0;
5541
5542 (void)self;
5543 if (!SWIG_Python_UnpackTuple(args, "plbop", 0, 0, 0)) SWIG_fail;
5544 plbop();
5545 resultobj = SWIG_Py_Void();
5546 return resultobj;
5547fail:
5548 return NULL;
5549}
5550
5551
5552SWIGINTERN PyObject *_wrap_plbox(PyObject *self, PyObject *args) {
5553 PyObject *resultobj = 0;
5554 char *arg1 = (char *) 0 ;
5555 PLFLT arg2 ;
5556 PLINT arg3 ;
5557 char *arg4 = (char *) 0 ;
5558 PLFLT arg5 ;
5559 PLINT arg6 ;
5560 int res1 ;
5561 char *buf1 = 0 ;
5562 int alloc1 = 0 ;
5563 double val2 ;
5564 int ecode2 = 0 ;
5565 int val3 ;
5566 int ecode3 = 0 ;
5567 int res4 ;
5568 char *buf4 = 0 ;
5569 int alloc4 = 0 ;
5570 double val5 ;
5571 int ecode5 = 0 ;
5572 int val6 ;
5573 int ecode6 = 0 ;
5574 PyObject *swig_obj[6] ;
5575
5576 (void)self;
5577 if (!SWIG_Python_UnpackTuple(args, "plbox", 6, 6, swig_obj)) SWIG_fail;
5578 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5579 if (!SWIG_IsOK(res1)) {
5580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5581 }
5582 arg1 = (char *)(buf1);
5583 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5584 if (!SWIG_IsOK(ecode2)) {
5585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5586 }
5587 arg2 = (PLFLT)(val2);
5588 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5589 if (!SWIG_IsOK(ecode3)) {
5590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5591 }
5592 arg3 = (PLINT)(val3);
5593 res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
5594 if (!SWIG_IsOK(res4)) {
5595 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5596 }
5597 arg4 = (char *)(buf4);
5598 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5599 if (!SWIG_IsOK(ecode5)) {
5600 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5601 }
5602 arg5 = (PLFLT)(val5);
5603 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5604 if (!SWIG_IsOK(ecode6)) {
5605 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5606 }
5607 arg6 = (PLINT)(val6);
5608 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5609 resultobj = SWIG_Py_Void();
5610 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5611 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5612 return resultobj;
5613fail:
5614 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5615 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5616 return NULL;
5617}
5618
5619
5620SWIGINTERN PyObject *_wrap_plbox3(PyObject *self, PyObject *args) {
5621 PyObject *resultobj = 0;
5622 char *arg1 = (char *) 0 ;
5623 char *arg2 = (char *) 0 ;
5624 PLFLT arg3 ;
5625 PLINT arg4 ;
5626 char *arg5 = (char *) 0 ;
5627 char *arg6 = (char *) 0 ;
5628 PLFLT arg7 ;
5629 PLINT arg8 ;
5630 char *arg9 = (char *) 0 ;
5631 char *arg10 = (char *) 0 ;
5632 PLFLT arg11 ;
5633 PLINT arg12 ;
5634 int res1 ;
5635 char *buf1 = 0 ;
5636 int alloc1 = 0 ;
5637 int res2 ;
5638 char *buf2 = 0 ;
5639 int alloc2 = 0 ;
5640 double val3 ;
5641 int ecode3 = 0 ;
5642 int val4 ;
5643 int ecode4 = 0 ;
5644 int res5 ;
5645 char *buf5 = 0 ;
5646 int alloc5 = 0 ;
5647 int res6 ;
5648 char *buf6 = 0 ;
5649 int alloc6 = 0 ;
5650 double val7 ;
5651 int ecode7 = 0 ;
5652 int val8 ;
5653 int ecode8 = 0 ;
5654 int res9 ;
5655 char *buf9 = 0 ;
5656 int alloc9 = 0 ;
5657 int res10 ;
5658 char *buf10 = 0 ;
5659 int alloc10 = 0 ;
5660 double val11 ;
5661 int ecode11 = 0 ;
5662 int val12 ;
5663 int ecode12 = 0 ;
5664 PyObject *swig_obj[12] ;
5665
5666 (void)self;
5667 if (!SWIG_Python_UnpackTuple(args, "plbox3", 12, 12, swig_obj)) SWIG_fail;
5668 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5669 if (!SWIG_IsOK(res1)) {
5670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5671 }
5672 arg1 = (char *)(buf1);
5673 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
5674 if (!SWIG_IsOK(res2)) {
5675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5676 }
5677 arg2 = (char *)(buf2);
5678 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5679 if (!SWIG_IsOK(ecode3)) {
5680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5681 }
5682 arg3 = (PLFLT)(val3);
5683 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5684 if (!SWIG_IsOK(ecode4)) {
5685 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5686 }
5687 arg4 = (PLINT)(val4);
5688 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
5689 if (!SWIG_IsOK(res5)) {
5690 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5691 }
5692 arg5 = (char *)(buf5);
5693 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5694 if (!SWIG_IsOK(res6)) {
5695 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5696 }
5697 arg6 = (char *)(buf6);
5698 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5699 if (!SWIG_IsOK(ecode7)) {
5700 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5701 }
5702 arg7 = (PLFLT)(val7);
5703 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5704 if (!SWIG_IsOK(ecode8)) {
5705 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5706 }
5707 arg8 = (PLINT)(val8);
5708 res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
5709 if (!SWIG_IsOK(res9)) {
5710 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5711 }
5712 arg9 = (char *)(buf9);
5713 res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
5714 if (!SWIG_IsOK(res10)) {
5715 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5716 }
5717 arg10 = (char *)(buf10);
5718 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5719 if (!SWIG_IsOK(ecode11)) {
5720 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5721 }
5722 arg11 = (PLFLT)(val11);
5723 ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
5724 if (!SWIG_IsOK(ecode12)) {
5725 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5726 }
5727 arg12 = (PLINT)(val12);
5728 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);
5729 resultobj = SWIG_Py_Void();
5730 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5731 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5732 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5733 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5734 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5735 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5736 return resultobj;
5737fail:
5738 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5739 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5740 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5741 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5742 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5743 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5744 return NULL;
5745}
5746
5747
5748SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *self, PyObject *args) {
5749 PyObject *resultobj = 0;
5750 PLFLT arg1 ;
5751 PLFLT arg2 ;
5752 PLFLT *arg3 = (PLFLT *) 0 ;
5753 PLFLT *arg4 = (PLFLT *) 0 ;
5754 PLINT *arg5 = (PLINT *) 0 ;
5755 double val1 ;
5756 int ecode1 = 0 ;
5757 double val2 ;
5758 int ecode2 = 0 ;
5759 PLFLT temp3 ;
5760 int res3 = SWIG_TMPOBJ ;
5761 PLFLT temp4 ;
5762 int res4 = SWIG_TMPOBJ ;
5763 PLINT temp5 ;
5764 int res5 = SWIG_TMPOBJ ;
5765 PyObject *swig_obj[2] ;
5766
5767 arg3 = &temp3;
5768 arg4 = &temp4;
5769 arg5 = &temp5;
5770 (void)self;
5771 if (!SWIG_Python_UnpackTuple(args, "plcalc_world", 2, 2, swig_obj)) SWIG_fail;
5772 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5773 if (!SWIG_IsOK(ecode1)) {
5774 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5775 }
5776 arg1 = (PLFLT)(val1);
5777 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5778 if (!SWIG_IsOK(ecode2)) {
5779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5780 }
5781 arg2 = (PLFLT)(val2);
5782 plcalc_world(arg1,arg2,arg3,arg4,arg5);
5783 resultobj = SWIG_Py_Void();
5784 if (SWIG_IsTmpObj(res3)) {
5785 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5786 } else {
5787 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5788 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5789 }
5790 if (SWIG_IsTmpObj(res4)) {
5791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5792 } else {
5793 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5795 }
5796 if (SWIG_IsTmpObj(res5)) {
5797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5798 } else {
5799 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5801 }
5802 return resultobj;
5803fail:
5804 return NULL;
5805}
5806
5807
5808SWIGINTERN PyObject *_wrap_plclear(PyObject *self, PyObject *args) {
5809 PyObject *resultobj = 0;
5810
5811 (void)self;
5812 if (!SWIG_Python_UnpackTuple(args, "plclear", 0, 0, 0)) SWIG_fail;
5813 plclear();
5814 resultobj = SWIG_Py_Void();
5815 return resultobj;
5816fail:
5817 return NULL;
5818}
5819
5820
5821SWIGINTERN PyObject *_wrap_plcol0(PyObject *self, PyObject *args) {
5822 PyObject *resultobj = 0;
5823 PLINT arg1 ;
5824 int val1 ;
5825 int ecode1 = 0 ;
5826 PyObject *swig_obj[1] ;
5827
5828 (void)self;
5829 if (!args) SWIG_fail;
5830 swig_obj[0] = args;
5831 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5832 if (!SWIG_IsOK(ecode1)) {
5833 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5834 }
5835 arg1 = (PLINT)(val1);
5836 plcol0(arg1);
5837 resultobj = SWIG_Py_Void();
5838 return resultobj;
5839fail:
5840 return NULL;
5841}
5842
5843
5844SWIGINTERN PyObject *_wrap_plcol1(PyObject *self, PyObject *args) {
5845 PyObject *resultobj = 0;
5846 PLFLT arg1 ;
5847 double val1 ;
5848 int ecode1 = 0 ;
5849 PyObject *swig_obj[1] ;
5850
5851 (void)self;
5852 if (!args) SWIG_fail;
5853 swig_obj[0] = args;
5854 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5855 if (!SWIG_IsOK(ecode1)) {
5856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5857 }
5858 arg1 = (PLFLT)(val1);
5859 plcol1(arg1);
5860 resultobj = SWIG_Py_Void();
5861 return resultobj;
5862fail:
5863 return NULL;
5864}
5865
5866
5867SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *self, PyObject *args) {
5868 PyObject *resultobj = 0;
5869 PLFLT arg1 ;
5870 PLFLT arg2 ;
5871 PLFLT arg3 ;
5872 PLINT arg4 ;
5873 PLBOOL arg5 ;
5874 PLINT arg6 ;
5875 PLINT arg7 ;
5876 PLINT arg8 ;
5877 PLINT arg9 ;
5878 PLINT arg10 ;
5879 PLFLT arg11 ;
5880 double val1 ;
5881 int ecode1 = 0 ;
5882 double val2 ;
5883 int ecode2 = 0 ;
5884 double val3 ;
5885 int ecode3 = 0 ;
5886 int val4 ;
5887 int ecode4 = 0 ;
5888 int val5 ;
5889 int ecode5 = 0 ;
5890 int val6 ;
5891 int ecode6 = 0 ;
5892 int val7 ;
5893 int ecode7 = 0 ;
5894 int val8 ;
5895 int ecode8 = 0 ;
5896 int val9 ;
5897 int ecode9 = 0 ;
5898 int val10 ;
5899 int ecode10 = 0 ;
5900 double val11 ;
5901 int ecode11 = 0 ;
5902 PyObject *swig_obj[11] ;
5903
5904 (void)self;
5905 if (!SWIG_Python_UnpackTuple(args, "plconfigtime", 11, 11, swig_obj)) SWIG_fail;
5906 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5907 if (!SWIG_IsOK(ecode1)) {
5908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5909 }
5910 arg1 = (PLFLT)(val1);
5911 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5912 if (!SWIG_IsOK(ecode2)) {
5913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5914 }
5915 arg2 = (PLFLT)(val2);
5916 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5917 if (!SWIG_IsOK(ecode3)) {
5918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5919 }
5920 arg3 = (PLFLT)(val3);
5921 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5922 if (!SWIG_IsOK(ecode4)) {
5923 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5924 }
5925 arg4 = (PLINT)(val4);
5926 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5927 if (!SWIG_IsOK(ecode5)) {
5928 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5929 }
5930 arg5 = (PLBOOL)(val5);
5931 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5932 if (!SWIG_IsOK(ecode6)) {
5933 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5934 }
5935 arg6 = (PLINT)(val6);
5936 ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
5937 if (!SWIG_IsOK(ecode7)) {
5938 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5939 }
5940 arg7 = (PLINT)(val7);
5941 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5942 if (!SWIG_IsOK(ecode8)) {
5943 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5944 }
5945 arg8 = (PLINT)(val8);
5946 ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
5947 if (!SWIG_IsOK(ecode9)) {
5948 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5949 }
5950 arg9 = (PLINT)(val9);
5951 ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
5952 if (!SWIG_IsOK(ecode10)) {
5953 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5954 }
5955 arg10 = (PLINT)(val10);
5956 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5957 if (!SWIG_IsOK(ecode11)) {
5958 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5959 }
5960 arg11 = (PLFLT)(val11);
5961 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5962 resultobj = SWIG_Py_Void();
5963 return resultobj;
5964fail:
5965 return NULL;
5966}
5967
5968
5969SWIGINTERN PyObject *_wrap_plcont(PyObject *self, PyObject *args) {
5970 PyObject *resultobj = 0;
5971 PLFLT **arg1 = (PLFLT **) 0 ;
5972 PLINT arg2 ;
5973 PLINT arg3 ;
5974 PLINT arg4 ;
5975 PLINT arg5 ;
5976 PLINT arg6 ;
5977 PLINT arg7 ;
5978 PLFLT *arg8 = (PLFLT *) 0 ;
5979 PLINT arg9 ;
5980 pltr_func arg10 = (pltr_func) 0 ;
5981 PLPointer arg11 = (PLPointer) 0 ;
5982 PyArrayObject *tmp1 = NULL ;
5983 int val4 ;
5984 int ecode4 = 0 ;
5985 int val5 ;
5986 int ecode5 = 0 ;
5987 int val6 ;
5988 int ecode6 = 0 ;
5989 int val7 ;
5990 int ecode7 = 0 ;
5991 PyArrayObject *tmp8 = NULL ;
5992 PyObject *swig_obj[8] ;
5993
5994 {
5995 python_pltr = 0;
5996 arg10 = NULL;
5997 }
5998 {
5999 arg11 = NULL;
6000 }
6001 (void)self;
6002 if (!SWIG_Python_UnpackTuple(args, "plcont", 6, 8, swig_obj)) SWIG_fail;
6003 {
6004 int i, size;
6005 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
6006 if ( tmp1 == NULL )
6007 return NULL;
6008 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
6009 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
6010 size = arg3;
6011 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
6012 for ( i = 0; i < arg2; i++ )
6013 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
6014 }
6015 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
6016 if (!SWIG_IsOK(ecode4)) {
6017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
6018 }
6019 arg4 = (PLINT)(val4);
6020 ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
6021 if (!SWIG_IsOK(ecode5)) {
6022 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
6023 }
6024 arg5 = (PLINT)(val5);
6025 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
6026 if (!SWIG_IsOK(ecode6)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
6028 }
6029 arg6 = (PLINT)(val6);
6030 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
6031 if (!SWIG_IsOK(ecode7)) {
6032 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
6033 }
6034 arg7 = (PLINT)(val7);
6035 {
6036 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
6037 if ( tmp8 == NULL )
6038 return NULL;
6039 arg9 = PyArray_DIMS( tmp8 )[0];
6040 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
6041 }
6042 if (swig_obj[6]) {
6043 {
6044 // it must be a callable or None
6045 if ( swig_obj[6] == Py_None )
6046 {
6047 arg10 = NULL;
6048 }
6049 else
6050 {
6051 if ( !PyCallable_Check( (PyObject *) swig_obj[6] ) )
6052 {
6053 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
6054 return NULL;
6055 }
6056 arg10 = marshal_pltr( swig_obj[6] );
6057 }
6058 }
6059 }
6060 if (swig_obj[7]) {
6061 {
6062 if ( swig_obj[7] == Py_None )
6063 arg11 = NULL;
6064 else
6065 {
6066 arg11 = marshal_PLPointer( swig_obj[7], 0 );
6067 }
6068 }
6069 }
6070 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
6071 resultobj = SWIG_Py_Void();
6072 {
6073 Py_CLEAR( tmp1 );
6074 free( arg1 );
6075 }
6076 {
6077 Py_CLEAR( tmp8 );
6078 }
6079 {
6080 cleanup_pltr();
6081 }
6082 {
6084 }
6085 return resultobj;
6086fail:
6087 {
6088 Py_CLEAR( tmp1 );
6089 free( arg1 );
6090 }
6091 {
6092 Py_CLEAR( tmp8 );
6093 }
6094 {
6095 cleanup_pltr();
6096 }
6097 {
6099 }
6100 return NULL;
6101}
6102
6103
6104SWIGINTERN PyObject *_wrap_plctime(PyObject *self, PyObject *args) {
6105 PyObject *resultobj = 0;
6106 PLINT arg1 ;
6107 PLINT arg2 ;
6108 PLINT arg3 ;
6109 PLINT arg4 ;
6110 PLINT arg5 ;
6111 PLFLT arg6 ;
6112 PLFLT *arg7 = (PLFLT *) 0 ;
6113 int val1 ;
6114 int ecode1 = 0 ;
6115 int val2 ;
6116 int ecode2 = 0 ;
6117 int val3 ;
6118 int ecode3 = 0 ;
6119 int val4 ;
6120 int ecode4 = 0 ;
6121 int val5 ;
6122 int ecode5 = 0 ;
6123 double val6 ;
6124 int ecode6 = 0 ;
6125 PLFLT temp7 ;
6126 int res7 = SWIG_TMPOBJ ;
6127 PyObject *swig_obj[6] ;
6128
6129 arg7 = &temp7;
6130 (void)self;
6131 if (!SWIG_Python_UnpackTuple(args, "plctime", 6, 6, swig_obj)) SWIG_fail;
6132 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6133 if (!SWIG_IsOK(ecode1)) {
6134 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
6135 }
6136 arg1 = (PLINT)(val1);
6137 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6138 if (!SWIG_IsOK(ecode2)) {
6139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
6140 }
6141 arg2 = (PLINT)(val2);
6142 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
6143 if (!SWIG_IsOK(ecode3)) {
6144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
6145 }
6146 arg3 = (PLINT)(val3);
6147 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
6148 if (!SWIG_IsOK(ecode4)) {
6149 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
6150 }
6151 arg4 = (PLINT)(val4);
6152 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6153 if (!SWIG_IsOK(ecode5)) {
6154 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
6155 }
6156 arg5 = (PLINT)(val5);
6157 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
6158 if (!SWIG_IsOK(ecode6)) {
6159 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
6160 }
6161 arg6 = (PLFLT)(val6);
6162 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
6163 resultobj = SWIG_Py_Void();
6164 if (SWIG_IsTmpObj(res7)) {
6165 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
6166 } else {
6167 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6168 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
6169 }
6170 return resultobj;
6171fail:
6172 return NULL;
6173}
6174
6175
6176SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *self, PyObject *args) {
6177 PyObject *resultobj = 0;
6178 PLINT arg1 ;
6179 PLBOOL arg2 ;
6180 int val1 ;
6181 int ecode1 = 0 ;
6182 int val2 ;
6183 int ecode2 = 0 ;
6184 PyObject *swig_obj[2] ;
6185
6186 (void)self;
6187 if (!SWIG_Python_UnpackTuple(args, "plcpstrm", 2, 2, swig_obj)) SWIG_fail;
6188 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6189 if (!SWIG_IsOK(ecode1)) {
6190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
6191 }
6192 arg1 = (PLINT)(val1);
6193 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6194 if (!SWIG_IsOK(ecode2)) {
6195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
6196 }
6197 arg2 = (PLBOOL)(val2);
6198 plcpstrm(arg1,arg2);
6199 resultobj = SWIG_Py_Void();
6200 return resultobj;
6201fail:
6202 return NULL;
6203}
6204
6205
6206SWIGINTERN PyObject *_wrap_plend(PyObject *self, PyObject *args) {
6207 PyObject *resultobj = 0;
6208
6209 (void)self;
6210 if (!SWIG_Python_UnpackTuple(args, "plend", 0, 0, 0)) SWIG_fail;
6211 plend();
6212 resultobj = SWIG_Py_Void();
6213 return resultobj;
6214fail:
6215 return NULL;
6216}
6217
6218
6219SWIGINTERN PyObject *_wrap_plend1(PyObject *self, PyObject *args) {
6220 PyObject *resultobj = 0;
6221
6222 (void)self;
6223 if (!SWIG_Python_UnpackTuple(args, "plend1", 0, 0, 0)) SWIG_fail;
6224 plend1();
6225 resultobj = SWIG_Py_Void();
6226 return resultobj;
6227fail:
6228 return NULL;
6229}
6230
6231
6232SWIGINTERN PyObject *_wrap_plenv(PyObject *self, PyObject *args) {
6233 PyObject *resultobj = 0;
6234 PLFLT arg1 ;
6235 PLFLT arg2 ;
6236 PLFLT arg3 ;
6237 PLFLT arg4 ;
6238 PLINT arg5 ;
6239 PLINT arg6 ;
6240 double val1 ;
6241 int ecode1 = 0 ;
6242 double val2 ;
6243 int ecode2 = 0 ;
6244 double val3 ;
6245 int ecode3 = 0 ;
6246 double val4 ;
6247 int ecode4 = 0 ;
6248 int val5 ;
6249 int ecode5 = 0 ;
6250 int val6 ;
6251 int ecode6 = 0 ;
6252 PyObject *swig_obj[6] ;
6253
6254 (void)self;
6255 if (!SWIG_Python_UnpackTuple(args, "plenv", 6, 6, swig_obj)) SWIG_fail;
6256 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6257 if (!SWIG_IsOK(ecode1)) {
6258 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
6259 }
6260 arg1 = (PLFLT)(val1);
6261 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6262 if (!SWIG_IsOK(ecode2)) {
6263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
6264 }
6265 arg2 = (PLFLT)(val2);
6266 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6267 if (!SWIG_IsOK(ecode3)) {
6268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
6269 }
6270 arg3 = (PLFLT)(val3);
6271 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6272 if (!SWIG_IsOK(ecode4)) {
6273 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
6274 }
6275 arg4 = (PLFLT)(val4);
6276 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6277 if (!SWIG_IsOK(ecode5)) {
6278 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
6279 }
6280 arg5 = (PLINT)(val5);
6281 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6282 if (!SWIG_IsOK(ecode6)) {
6283 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6284 }
6285 arg6 = (PLINT)(val6);
6286 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6287 resultobj = SWIG_Py_Void();
6288 return resultobj;
6289fail:
6290 return NULL;
6291}
6292
6293
6294SWIGINTERN PyObject *_wrap_plenv0(PyObject *self, PyObject *args) {
6295 PyObject *resultobj = 0;
6296 PLFLT arg1 ;
6297 PLFLT arg2 ;
6298 PLFLT arg3 ;
6299 PLFLT arg4 ;
6300 PLINT arg5 ;
6301 PLINT arg6 ;
6302 double val1 ;
6303 int ecode1 = 0 ;
6304 double val2 ;
6305 int ecode2 = 0 ;
6306 double val3 ;
6307 int ecode3 = 0 ;
6308 double val4 ;
6309 int ecode4 = 0 ;
6310 int val5 ;
6311 int ecode5 = 0 ;
6312 int val6 ;
6313 int ecode6 = 0 ;
6314 PyObject *swig_obj[6] ;
6315
6316 (void)self;
6317 if (!SWIG_Python_UnpackTuple(args, "plenv0", 6, 6, swig_obj)) SWIG_fail;
6318 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6319 if (!SWIG_IsOK(ecode1)) {
6320 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6321 }
6322 arg1 = (PLFLT)(val1);
6323 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6324 if (!SWIG_IsOK(ecode2)) {
6325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6326 }
6327 arg2 = (PLFLT)(val2);
6328 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6329 if (!SWIG_IsOK(ecode3)) {
6330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6331 }
6332 arg3 = (PLFLT)(val3);
6333 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6334 if (!SWIG_IsOK(ecode4)) {
6335 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6336 }
6337 arg4 = (PLFLT)(val4);
6338 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6339 if (!SWIG_IsOK(ecode5)) {
6340 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6341 }
6342 arg5 = (PLINT)(val5);
6343 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6344 if (!SWIG_IsOK(ecode6)) {
6345 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6346 }
6347 arg6 = (PLINT)(val6);
6348 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6349 resultobj = SWIG_Py_Void();
6350 return resultobj;
6351fail:
6352 return NULL;
6353}
6354
6355
6356SWIGINTERN PyObject *_wrap_pleop(PyObject *self, PyObject *args) {
6357 PyObject *resultobj = 0;
6358
6359 (void)self;
6360 if (!SWIG_Python_UnpackTuple(args, "pleop", 0, 0, 0)) SWIG_fail;
6361 pleop();
6362 resultobj = SWIG_Py_Void();
6363 return resultobj;
6364fail:
6365 return NULL;
6366}
6367
6368
6369SWIGINTERN PyObject *_wrap_plerrx(PyObject *self, PyObject *args) {
6370 PyObject *resultobj = 0;
6371 PLINT arg1 ;
6372 PLFLT *arg2 = (PLFLT *) 0 ;
6373 PLFLT *arg3 = (PLFLT *) 0 ;
6374 PLFLT *arg4 = (PLFLT *) 0 ;
6375 PyArrayObject *tmp1 = NULL ;
6376 PyArrayObject *tmp3 = NULL ;
6377 PyArrayObject *tmp4 = NULL ;
6378 PyObject *swig_obj[3] ;
6379
6380 (void)self;
6381 if (!SWIG_Python_UnpackTuple(args, "plerrx", 3, 3, swig_obj)) SWIG_fail;
6382 {
6383 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6384 if ( tmp1 == NULL )
6385 return NULL;
6386 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6387 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6388 }
6389 {
6390 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6391 if ( tmp3 == NULL )
6392 return NULL;
6393 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6394 {
6395 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6396 return NULL;
6397 }
6398 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6399 }
6400 {
6401 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6402 if ( tmp4 == NULL )
6403 return NULL;
6404 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6405 {
6406 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6407 return NULL;
6408 }
6409 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6410 }
6411 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6412 resultobj = SWIG_Py_Void();
6413 {
6414 Py_CLEAR( tmp1 );
6415 }
6416 {
6417 Py_CLEAR( tmp3 );
6418 }
6419 {
6420 Py_CLEAR( tmp4 );
6421 }
6422 return resultobj;
6423fail:
6424 {
6425 Py_CLEAR( tmp1 );
6426 }
6427 {
6428 Py_CLEAR( tmp3 );
6429 }
6430 {
6431 Py_CLEAR( tmp4 );
6432 }
6433 return NULL;
6434}
6435
6436
6437SWIGINTERN PyObject *_wrap_plerry(PyObject *self, PyObject *args) {
6438 PyObject *resultobj = 0;
6439 PLINT arg1 ;
6440 PLFLT *arg2 = (PLFLT *) 0 ;
6441 PLFLT *arg3 = (PLFLT *) 0 ;
6442 PLFLT *arg4 = (PLFLT *) 0 ;
6443 PyArrayObject *tmp1 = NULL ;
6444 PyArrayObject *tmp3 = NULL ;
6445 PyArrayObject *tmp4 = NULL ;
6446 PyObject *swig_obj[3] ;
6447
6448 (void)self;
6449 if (!SWIG_Python_UnpackTuple(args, "plerry", 3, 3, swig_obj)) SWIG_fail;
6450 {
6451 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6452 if ( tmp1 == NULL )
6453 return NULL;
6454 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6455 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6456 }
6457 {
6458 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6459 if ( tmp3 == NULL )
6460 return NULL;
6461 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6462 {
6463 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6464 return NULL;
6465 }
6466 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6467 }
6468 {
6469 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6470 if ( tmp4 == NULL )
6471 return NULL;
6472 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6473 {
6474 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6475 return NULL;
6476 }
6477 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6478 }
6479 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6480 resultobj = SWIG_Py_Void();
6481 {
6482 Py_CLEAR( tmp1 );
6483 }
6484 {
6485 Py_CLEAR( tmp3 );
6486 }
6487 {
6488 Py_CLEAR( tmp4 );
6489 }
6490 return resultobj;
6491fail:
6492 {
6493 Py_CLEAR( tmp1 );
6494 }
6495 {
6496 Py_CLEAR( tmp3 );
6497 }
6498 {
6499 Py_CLEAR( tmp4 );
6500 }
6501 return NULL;
6502}
6503
6504
6505SWIGINTERN PyObject *_wrap_plfamadv(PyObject *self, PyObject *args) {
6506 PyObject *resultobj = 0;
6507
6508 (void)self;
6509 if (!SWIG_Python_UnpackTuple(args, "plfamadv", 0, 0, 0)) SWIG_fail;
6510 plfamadv();
6511 resultobj = SWIG_Py_Void();
6512 return resultobj;
6513fail:
6514 return NULL;
6515}
6516
6517
6518SWIGINTERN PyObject *_wrap_plfill(PyObject *self, PyObject *args) {
6519 PyObject *resultobj = 0;
6520 PLINT arg1 ;
6521 PLFLT *arg2 = (PLFLT *) 0 ;
6522 PLFLT *arg3 = (PLFLT *) 0 ;
6523 PyArrayObject *tmp1 = NULL ;
6524 PyArrayObject *tmp3 = NULL ;
6525 PyObject *swig_obj[2] ;
6526
6527 (void)self;
6528 if (!SWIG_Python_UnpackTuple(args, "plfill", 2, 2, swig_obj)) SWIG_fail;
6529 {
6530 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6531 if ( tmp1 == NULL )
6532 return NULL;
6533 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6534 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6535 }
6536 {
6537 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6538 if ( tmp3 == NULL )
6539 return NULL;
6540 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6541 {
6542 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6543 return NULL;
6544 }
6545 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6546 }
6547 plfill(arg1,(double const *)arg2,(double const *)arg3);
6548 resultobj = SWIG_Py_Void();
6549 {
6550 Py_CLEAR( tmp1 );
6551 }
6552 {
6553 Py_CLEAR( tmp3 );
6554 }
6555 return resultobj;
6556fail:
6557 {
6558 Py_CLEAR( tmp1 );
6559 }
6560 {
6561 Py_CLEAR( tmp3 );
6562 }
6563 return NULL;
6564}
6565
6566
6567SWIGINTERN PyObject *_wrap_plfill3(PyObject *self, PyObject *args) {
6568 PyObject *resultobj = 0;
6569 PLINT arg1 ;
6570 PLFLT *arg2 = (PLFLT *) 0 ;
6571 PLFLT *arg3 = (PLFLT *) 0 ;
6572 PLFLT *arg4 = (PLFLT *) 0 ;
6573 PyArrayObject *tmp1 = NULL ;
6574 PyArrayObject *tmp3 = NULL ;
6575 PyArrayObject *tmp4 = NULL ;
6576 PyObject *swig_obj[3] ;
6577
6578 (void)self;
6579 if (!SWIG_Python_UnpackTuple(args, "plfill3", 3, 3, swig_obj)) SWIG_fail;
6580 {
6581 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6582 if ( tmp1 == NULL )
6583 return NULL;
6584 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6585 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6586 }
6587 {
6588 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6589 if ( tmp3 == NULL )
6590 return NULL;
6591 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6592 {
6593 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6594 return NULL;
6595 }
6596 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6597 }
6598 {
6599 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6600 if ( tmp4 == NULL )
6601 return NULL;
6602 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6603 {
6604 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6605 return NULL;
6606 }
6607 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6608 }
6609 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6610 resultobj = SWIG_Py_Void();
6611 {
6612 Py_CLEAR( tmp1 );
6613 }
6614 {
6615 Py_CLEAR( tmp3 );
6616 }
6617 {
6618 Py_CLEAR( tmp4 );
6619 }
6620 return resultobj;
6621fail:
6622 {
6623 Py_CLEAR( tmp1 );
6624 }
6625 {
6626 Py_CLEAR( tmp3 );
6627 }
6628 {
6629 Py_CLEAR( tmp4 );
6630 }
6631 return NULL;
6632}
6633
6634
6635SWIGINTERN PyObject *_wrap_plgradient(PyObject *self, PyObject *args) {
6636 PyObject *resultobj = 0;
6637 PLINT arg1 ;
6638 PLFLT *arg2 = (PLFLT *) 0 ;
6639 PLFLT *arg3 = (PLFLT *) 0 ;
6640 PLFLT arg4 ;
6641 PyArrayObject *tmp1 = NULL ;
6642 PyArrayObject *tmp3 = NULL ;
6643 double val4 ;
6644 int ecode4 = 0 ;
6645 PyObject *swig_obj[3] ;
6646
6647 (void)self;
6648 if (!SWIG_Python_UnpackTuple(args, "plgradient", 3, 3, swig_obj)) SWIG_fail;
6649 {
6650 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6651 if ( tmp1 == NULL )
6652 return NULL;
6653 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6654 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6655 }
6656 {
6657 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6658 if ( tmp3 == NULL )
6659 return NULL;
6660 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6661 {
6662 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6663 return NULL;
6664 }
6665 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6666 }
6667 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
6668 if (!SWIG_IsOK(ecode4)) {
6669 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6670 }
6671 arg4 = (PLFLT)(val4);
6672 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6673 resultobj = SWIG_Py_Void();
6674 {
6675 Py_CLEAR( tmp1 );
6676 }
6677 {
6678 Py_CLEAR( tmp3 );
6679 }
6680 return resultobj;
6681fail:
6682 {
6683 Py_CLEAR( tmp1 );
6684 }
6685 {
6686 Py_CLEAR( tmp3 );
6687 }
6688 return NULL;
6689}
6690
6691
6692SWIGINTERN PyObject *_wrap_plflush(PyObject *self, PyObject *args) {
6693 PyObject *resultobj = 0;
6694
6695 (void)self;
6696 if (!SWIG_Python_UnpackTuple(args, "plflush", 0, 0, 0)) SWIG_fail;
6697 plflush();
6698 resultobj = SWIG_Py_Void();
6699 return resultobj;
6700fail:
6701 return NULL;
6702}
6703
6704
6705SWIGINTERN PyObject *_wrap_plfont(PyObject *self, PyObject *args) {
6706 PyObject *resultobj = 0;
6707 PLINT arg1 ;
6708 int val1 ;
6709 int ecode1 = 0 ;
6710 PyObject *swig_obj[1] ;
6711
6712 (void)self;
6713 if (!args) SWIG_fail;
6714 swig_obj[0] = args;
6715 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6716 if (!SWIG_IsOK(ecode1)) {
6717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6718 }
6719 arg1 = (PLINT)(val1);
6720 plfont(arg1);
6721 resultobj = SWIG_Py_Void();
6722 return resultobj;
6723fail:
6724 return NULL;
6725}
6726
6727
6728SWIGINTERN PyObject *_wrap_plfontld(PyObject *self, PyObject *args) {
6729 PyObject *resultobj = 0;
6730 PLINT arg1 ;
6731 int val1 ;
6732 int ecode1 = 0 ;
6733 PyObject *swig_obj[1] ;
6734
6735 (void)self;
6736 if (!args) SWIG_fail;
6737 swig_obj[0] = args;
6738 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6739 if (!SWIG_IsOK(ecode1)) {
6740 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6741 }
6742 arg1 = (PLINT)(val1);
6743 plfontld(arg1);
6744 resultobj = SWIG_Py_Void();
6745 return resultobj;
6746fail:
6747 return NULL;
6748}
6749
6750
6751SWIGINTERN PyObject *_wrap_plgchr(PyObject *self, PyObject *args) {
6752 PyObject *resultobj = 0;
6753 PLFLT *arg1 = (PLFLT *) 0 ;
6754 PLFLT *arg2 = (PLFLT *) 0 ;
6755 PLFLT temp1 ;
6756 int res1 = SWIG_TMPOBJ ;
6757 PLFLT temp2 ;
6758 int res2 = SWIG_TMPOBJ ;
6759
6760 arg1 = &temp1;
6761 arg2 = &temp2;
6762 (void)self;
6763 if (!SWIG_Python_UnpackTuple(args, "plgchr", 0, 0, 0)) SWIG_fail;
6764 plgchr(arg1,arg2);
6765 resultobj = SWIG_Py_Void();
6766 if (SWIG_IsTmpObj(res1)) {
6767 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6768 } else {
6769 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6770 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6771 }
6772 if (SWIG_IsTmpObj(res2)) {
6773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6774 } else {
6775 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6776 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6777 }
6778 return resultobj;
6779fail:
6780 return NULL;
6781}
6782
6783
6784SWIGINTERN PyObject *_wrap_plgcol0(PyObject *self, PyObject *args) {
6785 PyObject *resultobj = 0;
6786 PLINT arg1 ;
6787 PLINT *arg2 = (PLINT *) 0 ;
6788 PLINT *arg3 = (PLINT *) 0 ;
6789 PLINT *arg4 = (PLINT *) 0 ;
6790 int val1 ;
6791 int ecode1 = 0 ;
6792 PLINT temp2 ;
6793 int res2 = SWIG_TMPOBJ ;
6794 PLINT temp3 ;
6795 int res3 = SWIG_TMPOBJ ;
6796 PLINT temp4 ;
6797 int res4 = SWIG_TMPOBJ ;
6798 PyObject *swig_obj[1] ;
6799
6800 arg2 = &temp2;
6801 arg3 = &temp3;
6802 arg4 = &temp4;
6803 (void)self;
6804 if (!args) SWIG_fail;
6805 swig_obj[0] = args;
6806 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6807 if (!SWIG_IsOK(ecode1)) {
6808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6809 }
6810 arg1 = (PLINT)(val1);
6811 plgcol0(arg1,arg2,arg3,arg4);
6812 resultobj = SWIG_Py_Void();
6813 if (SWIG_IsTmpObj(res2)) {
6814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6815 } else {
6816 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6818 }
6819 if (SWIG_IsTmpObj(res3)) {
6820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6821 } else {
6822 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6824 }
6825 if (SWIG_IsTmpObj(res4)) {
6826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6827 } else {
6828 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6829 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6830 }
6831 return resultobj;
6832fail:
6833 return NULL;
6834}
6835
6836
6837SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *self, PyObject *args) {
6838 PyObject *resultobj = 0;
6839 PLINT arg1 ;
6840 PLINT *arg2 = (PLINT *) 0 ;
6841 PLINT *arg3 = (PLINT *) 0 ;
6842 PLINT *arg4 = (PLINT *) 0 ;
6843 PLFLT *arg5 = (PLFLT *) 0 ;
6844 int val1 ;
6845 int ecode1 = 0 ;
6846 PLINT temp2 ;
6847 int res2 = SWIG_TMPOBJ ;
6848 PLINT temp3 ;
6849 int res3 = SWIG_TMPOBJ ;
6850 PLINT temp4 ;
6851 int res4 = SWIG_TMPOBJ ;
6852 PLFLT temp5 ;
6853 int res5 = SWIG_TMPOBJ ;
6854 PyObject *swig_obj[1] ;
6855
6856 arg2 = &temp2;
6857 arg3 = &temp3;
6858 arg4 = &temp4;
6859 arg5 = &temp5;
6860 (void)self;
6861 if (!args) SWIG_fail;
6862 swig_obj[0] = args;
6863 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6864 if (!SWIG_IsOK(ecode1)) {
6865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6866 }
6867 arg1 = (PLINT)(val1);
6868 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6869 resultobj = SWIG_Py_Void();
6870 if (SWIG_IsTmpObj(res2)) {
6871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6872 } else {
6873 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6875 }
6876 if (SWIG_IsTmpObj(res3)) {
6877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6878 } else {
6879 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6881 }
6882 if (SWIG_IsTmpObj(res4)) {
6883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6884 } else {
6885 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6887 }
6888 if (SWIG_IsTmpObj(res5)) {
6889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6890 } else {
6891 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6893 }
6894 return resultobj;
6895fail:
6896 return NULL;
6897}
6898
6899
6900SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *self, PyObject *args) {
6901 PyObject *resultobj = 0;
6902 PLINT *arg1 = (PLINT *) 0 ;
6903 PLINT *arg2 = (PLINT *) 0 ;
6904 PLINT *arg3 = (PLINT *) 0 ;
6905 PLINT temp1 ;
6906 int res1 = SWIG_TMPOBJ ;
6907 PLINT temp2 ;
6908 int res2 = SWIG_TMPOBJ ;
6909 PLINT temp3 ;
6910 int res3 = SWIG_TMPOBJ ;
6911
6912 arg1 = &temp1;
6913 arg2 = &temp2;
6914 arg3 = &temp3;
6915 (void)self;
6916 if (!SWIG_Python_UnpackTuple(args, "plgcolbg", 0, 0, 0)) SWIG_fail;
6917 plgcolbg(arg1,arg2,arg3);
6918 resultobj = SWIG_Py_Void();
6919 if (SWIG_IsTmpObj(res1)) {
6920 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6921 } else {
6922 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6924 }
6925 if (SWIG_IsTmpObj(res2)) {
6926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6927 } else {
6928 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6930 }
6931 if (SWIG_IsTmpObj(res3)) {
6932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6933 } else {
6934 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6936 }
6937 return resultobj;
6938fail:
6939 return NULL;
6940}
6941
6942
6943SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *self, PyObject *args) {
6944 PyObject *resultobj = 0;
6945 PLINT *arg1 = (PLINT *) 0 ;
6946 PLINT *arg2 = (PLINT *) 0 ;
6947 PLINT *arg3 = (PLINT *) 0 ;
6948 PLFLT *arg4 = (PLFLT *) 0 ;
6949 PLINT temp1 ;
6950 int res1 = SWIG_TMPOBJ ;
6951 PLINT temp2 ;
6952 int res2 = SWIG_TMPOBJ ;
6953 PLINT temp3 ;
6954 int res3 = SWIG_TMPOBJ ;
6955 PLFLT temp4 ;
6956 int res4 = SWIG_TMPOBJ ;
6957
6958 arg1 = &temp1;
6959 arg2 = &temp2;
6960 arg3 = &temp3;
6961 arg4 = &temp4;
6962 (void)self;
6963 if (!SWIG_Python_UnpackTuple(args, "plgcolbga", 0, 0, 0)) SWIG_fail;
6964 plgcolbga(arg1,arg2,arg3,arg4);
6965 resultobj = SWIG_Py_Void();
6966 if (SWIG_IsTmpObj(res1)) {
6967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6968 } else {
6969 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6971 }
6972 if (SWIG_IsTmpObj(res2)) {
6973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6974 } else {
6975 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6977 }
6978 if (SWIG_IsTmpObj(res3)) {
6979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6980 } else {
6981 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6983 }
6984 if (SWIG_IsTmpObj(res4)) {
6985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6986 } else {
6987 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6988 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6989 }
6990 return resultobj;
6991fail:
6992 return NULL;
6993}
6994
6995
6996SWIGINTERN PyObject *_wrap_plgcompression(PyObject *self, PyObject *args) {
6997 PyObject *resultobj = 0;
6998 PLINT *arg1 = (PLINT *) 0 ;
6999 PLINT temp1 ;
7000 int res1 = SWIG_TMPOBJ ;
7001
7002 arg1 = &temp1;
7003 (void)self;
7004 if (!SWIG_Python_UnpackTuple(args, "plgcompression", 0, 0, 0)) SWIG_fail;
7005 plgcompression(arg1);
7006 resultobj = SWIG_Py_Void();
7007 if (SWIG_IsTmpObj(res1)) {
7008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7009 } else {
7010 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7012 }
7013 return resultobj;
7014fail:
7015 return NULL;
7016}
7017
7018
7019SWIGINTERN PyObject *_wrap_plgdev(PyObject *self, PyObject *args) {
7020 PyObject *resultobj = 0;
7021 char *arg1 = (char *) 0 ;
7022 char buff1[1000] ;
7023
7024 {
7025 arg1 = buff1;
7026 }
7027 (void)self;
7028 if (!SWIG_Python_UnpackTuple(args, "plgdev", 0, 0, 0)) SWIG_fail;
7029 plgdev(arg1);
7030 resultobj = SWIG_Py_Void();
7031 {
7032 PyObject *o = PyString_FromString( arg1 );
7033 resultobj = t_output_helper( resultobj, o );
7034 }
7035 return resultobj;
7036fail:
7037 return NULL;
7038}
7039
7040
7041SWIGINTERN PyObject *_wrap_plgdidev(PyObject *self, PyObject *args) {
7042 PyObject *resultobj = 0;
7043 PLFLT *arg1 = (PLFLT *) 0 ;
7044 PLFLT *arg2 = (PLFLT *) 0 ;
7045 PLFLT *arg3 = (PLFLT *) 0 ;
7046 PLFLT *arg4 = (PLFLT *) 0 ;
7047 PLFLT temp1 ;
7048 int res1 = SWIG_TMPOBJ ;
7049 PLFLT temp2 ;
7050 int res2 = SWIG_TMPOBJ ;
7051 PLFLT temp3 ;
7052 int res3 = SWIG_TMPOBJ ;
7053 PLFLT temp4 ;
7054 int res4 = SWIG_TMPOBJ ;
7055
7056 arg1 = &temp1;
7057 arg2 = &temp2;
7058 arg3 = &temp3;
7059 arg4 = &temp4;
7060 (void)self;
7061 if (!SWIG_Python_UnpackTuple(args, "plgdidev", 0, 0, 0)) SWIG_fail;
7062 plgdidev(arg1,arg2,arg3,arg4);
7063 resultobj = SWIG_Py_Void();
7064 if (SWIG_IsTmpObj(res1)) {
7065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7066 } else {
7067 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7069 }
7070 if (SWIG_IsTmpObj(res2)) {
7071 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7072 } else {
7073 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7075 }
7076 if (SWIG_IsTmpObj(res3)) {
7077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7078 } else {
7079 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7081 }
7082 if (SWIG_IsTmpObj(res4)) {
7083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7084 } else {
7085 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7087 }
7088 return resultobj;
7089fail:
7090 return NULL;
7091}
7092
7093
7094SWIGINTERN PyObject *_wrap_plgdiori(PyObject *self, PyObject *args) {
7095 PyObject *resultobj = 0;
7096 PLFLT *arg1 = (PLFLT *) 0 ;
7097 PLFLT temp1 ;
7098 int res1 = SWIG_TMPOBJ ;
7099
7100 arg1 = &temp1;
7101 (void)self;
7102 if (!SWIG_Python_UnpackTuple(args, "plgdiori", 0, 0, 0)) SWIG_fail;
7103 plgdiori(arg1);
7104 resultobj = SWIG_Py_Void();
7105 if (SWIG_IsTmpObj(res1)) {
7106 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7107 } else {
7108 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7109 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7110 }
7111 return resultobj;
7112fail:
7113 return NULL;
7114}
7115
7116
7117SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *self, PyObject *args) {
7118 PyObject *resultobj = 0;
7119 PLFLT *arg1 = (PLFLT *) 0 ;
7120 PLFLT *arg2 = (PLFLT *) 0 ;
7121 PLFLT *arg3 = (PLFLT *) 0 ;
7122 PLFLT *arg4 = (PLFLT *) 0 ;
7123 PLFLT temp1 ;
7124 int res1 = SWIG_TMPOBJ ;
7125 PLFLT temp2 ;
7126 int res2 = SWIG_TMPOBJ ;
7127 PLFLT temp3 ;
7128 int res3 = SWIG_TMPOBJ ;
7129 PLFLT temp4 ;
7130 int res4 = SWIG_TMPOBJ ;
7131
7132 arg1 = &temp1;
7133 arg2 = &temp2;
7134 arg3 = &temp3;
7135 arg4 = &temp4;
7136 (void)self;
7137 if (!SWIG_Python_UnpackTuple(args, "plgdiplt", 0, 0, 0)) SWIG_fail;
7138 plgdiplt(arg1,arg2,arg3,arg4);
7139 resultobj = SWIG_Py_Void();
7140 if (SWIG_IsTmpObj(res1)) {
7141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7142 } else {
7143 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7145 }
7146 if (SWIG_IsTmpObj(res2)) {
7147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7148 } else {
7149 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7150 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7151 }
7152 if (SWIG_IsTmpObj(res3)) {
7153 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7154 } else {
7155 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7156 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7157 }
7158 if (SWIG_IsTmpObj(res4)) {
7159 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7160 } else {
7161 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7162 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7163 }
7164 return resultobj;
7165fail:
7166 return NULL;
7167}
7168
7169
7170SWIGINTERN PyObject *_wrap_plgfam(PyObject *self, PyObject *args) {
7171 PyObject *resultobj = 0;
7172 PLINT *arg1 = (PLINT *) 0 ;
7173 PLINT *arg2 = (PLINT *) 0 ;
7174 PLINT *arg3 = (PLINT *) 0 ;
7175 PLINT temp1 ;
7176 int res1 = SWIG_TMPOBJ ;
7177 PLINT temp2 ;
7178 int res2 = SWIG_TMPOBJ ;
7179 PLINT temp3 ;
7180 int res3 = SWIG_TMPOBJ ;
7181
7182 arg1 = &temp1;
7183 arg2 = &temp2;
7184 arg3 = &temp3;
7185 (void)self;
7186 if (!SWIG_Python_UnpackTuple(args, "plgfam", 0, 0, 0)) SWIG_fail;
7187 plgfam(arg1,arg2,arg3);
7188 resultobj = SWIG_Py_Void();
7189 if (SWIG_IsTmpObj(res1)) {
7190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7191 } else {
7192 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7194 }
7195 if (SWIG_IsTmpObj(res2)) {
7196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7197 } else {
7198 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7200 }
7201 if (SWIG_IsTmpObj(res3)) {
7202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7203 } else {
7204 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7206 }
7207 return resultobj;
7208fail:
7209 return NULL;
7210}
7211
7212
7213SWIGINTERN PyObject *_wrap_plgfci(PyObject *self, PyObject *args) {
7214 PyObject *resultobj = 0;
7215 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
7216 PLUNICODE temp1 ;
7217 int res1 = SWIG_TMPOBJ ;
7218
7219 arg1 = &temp1;
7220 (void)self;
7221 if (!SWIG_Python_UnpackTuple(args, "plgfci", 0, 0, 0)) SWIG_fail;
7222 plgfci(arg1);
7223 resultobj = SWIG_Py_Void();
7224 if (SWIG_IsTmpObj(res1)) {
7225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
7226 } else {
7227 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
7229 }
7230 return resultobj;
7231fail:
7232 return NULL;
7233}
7234
7235
7236SWIGINTERN PyObject *_wrap_plgfnam(PyObject *self, PyObject *args) {
7237 PyObject *resultobj = 0;
7238 char *arg1 = (char *) 0 ;
7239 char buff1[1000] ;
7240
7241 {
7242 arg1 = buff1;
7243 }
7244 (void)self;
7245 if (!SWIG_Python_UnpackTuple(args, "plgfnam", 0, 0, 0)) SWIG_fail;
7246 plgfnam(arg1);
7247 resultobj = SWIG_Py_Void();
7248 {
7249 PyObject *o = PyString_FromString( arg1 );
7250 resultobj = t_output_helper( resultobj, o );
7251 }
7252 return resultobj;
7253fail:
7254 return NULL;
7255}
7256
7257
7258SWIGINTERN PyObject *_wrap_plgfont(PyObject *self, PyObject *args) {
7259 PyObject *resultobj = 0;
7260 PLINT *arg1 = (PLINT *) 0 ;
7261 PLINT *arg2 = (PLINT *) 0 ;
7262 PLINT *arg3 = (PLINT *) 0 ;
7263 PLINT temp1 ;
7264 int res1 = SWIG_TMPOBJ ;
7265 PLINT temp2 ;
7266 int res2 = SWIG_TMPOBJ ;
7267 PLINT temp3 ;
7268 int res3 = SWIG_TMPOBJ ;
7269
7270 arg1 = &temp1;
7271 arg2 = &temp2;
7272 arg3 = &temp3;
7273 (void)self;
7274 if (!SWIG_Python_UnpackTuple(args, "plgfont", 0, 0, 0)) SWIG_fail;
7275 plgfont(arg1,arg2,arg3);
7276 resultobj = SWIG_Py_Void();
7277 if (SWIG_IsTmpObj(res1)) {
7278 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7279 } else {
7280 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7282 }
7283 if (SWIG_IsTmpObj(res2)) {
7284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7285 } else {
7286 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7288 }
7289 if (SWIG_IsTmpObj(res3)) {
7290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7291 } else {
7292 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7294 }
7295 return resultobj;
7296fail:
7297 return NULL;
7298}
7299
7300
7301SWIGINTERN PyObject *_wrap_plglevel(PyObject *self, PyObject *args) {
7302 PyObject *resultobj = 0;
7303 PLINT *arg1 = (PLINT *) 0 ;
7304 PLINT temp1 ;
7305 int res1 = SWIG_TMPOBJ ;
7306
7307 arg1 = &temp1;
7308 (void)self;
7309 if (!SWIG_Python_UnpackTuple(args, "plglevel", 0, 0, 0)) SWIG_fail;
7310 plglevel(arg1);
7311 resultobj = SWIG_Py_Void();
7312 if (SWIG_IsTmpObj(res1)) {
7313 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7314 } else {
7315 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7316 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7317 }
7318 return resultobj;
7319fail:
7320 return NULL;
7321}
7322
7323
7324SWIGINTERN PyObject *_wrap_plgpage(PyObject *self, PyObject *args) {
7325 PyObject *resultobj = 0;
7326 PLFLT *arg1 = (PLFLT *) 0 ;
7327 PLFLT *arg2 = (PLFLT *) 0 ;
7328 PLINT *arg3 = (PLINT *) 0 ;
7329 PLINT *arg4 = (PLINT *) 0 ;
7330 PLINT *arg5 = (PLINT *) 0 ;
7331 PLINT *arg6 = (PLINT *) 0 ;
7332 PLFLT temp1 ;
7333 int res1 = SWIG_TMPOBJ ;
7334 PLFLT temp2 ;
7335 int res2 = SWIG_TMPOBJ ;
7336 PLINT temp3 ;
7337 int res3 = SWIG_TMPOBJ ;
7338 PLINT temp4 ;
7339 int res4 = SWIG_TMPOBJ ;
7340 PLINT temp5 ;
7341 int res5 = SWIG_TMPOBJ ;
7342 PLINT temp6 ;
7343 int res6 = SWIG_TMPOBJ ;
7344
7345 arg1 = &temp1;
7346 arg2 = &temp2;
7347 arg3 = &temp3;
7348 arg4 = &temp4;
7349 arg5 = &temp5;
7350 arg6 = &temp6;
7351 (void)self;
7352 if (!SWIG_Python_UnpackTuple(args, "plgpage", 0, 0, 0)) SWIG_fail;
7353 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7354 resultobj = SWIG_Py_Void();
7355 if (SWIG_IsTmpObj(res1)) {
7356 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7357 } else {
7358 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7359 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7360 }
7361 if (SWIG_IsTmpObj(res2)) {
7362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7363 } else {
7364 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7366 }
7367 if (SWIG_IsTmpObj(res3)) {
7368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7369 } else {
7370 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7372 }
7373 if (SWIG_IsTmpObj(res4)) {
7374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
7375 } else {
7376 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7378 }
7379 if (SWIG_IsTmpObj(res5)) {
7380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
7381 } else {
7382 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7384 }
7385 if (SWIG_IsTmpObj(res6)) {
7386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
7387 } else {
7388 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
7390 }
7391 return resultobj;
7392fail:
7393 return NULL;
7394}
7395
7396
7397SWIGINTERN PyObject *_wrap_plgra(PyObject *self, PyObject *args) {
7398 PyObject *resultobj = 0;
7399
7400 (void)self;
7401 if (!SWIG_Python_UnpackTuple(args, "plgra", 0, 0, 0)) SWIG_fail;
7402 plgra();
7403 resultobj = SWIG_Py_Void();
7404 return resultobj;
7405fail:
7406 return NULL;
7407}
7408
7409
7410SWIGINTERN PyObject *_wrap_plgriddata(PyObject *self, PyObject *args) {
7411 PyObject *resultobj = 0;
7412 PLFLT *arg1 = (PLFLT *) 0 ;
7413 PLFLT *arg2 = (PLFLT *) 0 ;
7414 PLFLT *arg3 = (PLFLT *) 0 ;
7415 PLINT arg4 ;
7416 PLFLT *arg5 = (PLFLT *) 0 ;
7417 PLINT arg6 ;
7418 PLFLT *arg7 = (PLFLT *) 0 ;
7419 PLINT arg8 ;
7420 PLFLT **arg9 = (PLFLT **) 0 ;
7421 PLINT arg10 ;
7422 PLFLT arg11 ;
7423 PyArrayObject *tmp1 = NULL ;
7424 PyArrayObject *tmp2 = NULL ;
7425 PyArrayObject *tmp3 = NULL ;
7426 PyArrayObject *tmp5 = NULL ;
7427 PyArrayObject *tmp7 = NULL ;
7428 PyObject *array7 = NULL ;
7429 int val10 ;
7430 int ecode10 = 0 ;
7431 double val11 ;
7432 int ecode11 = 0 ;
7433 PyObject *swig_obj[7] ;
7434
7435 (void)self;
7436 if (!SWIG_Python_UnpackTuple(args, "plgriddata", 7, 7, swig_obj)) SWIG_fail;
7437 {
7438 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7439 if ( tmp1 == NULL )
7440 return NULL;
7441 Alen = PyArray_DIMS( tmp1 )[0];
7442 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7443 }
7444 {
7445 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
7446 if ( tmp2 == NULL )
7447 return NULL;
7448 if ( PyArray_DIMS( tmp2 )[0] != Alen )
7449 {
7450 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7451 return NULL;
7452 }
7453 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7454 }
7455 {
7456 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
7457 if ( tmp3 == NULL )
7458 return NULL;
7459 if ( PyArray_DIMS( tmp3 )[0] != Alen )
7460 {
7461 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7462 return NULL;
7463 }
7464 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7465 arg4 = PyArray_DIMS( tmp3 )[0];
7466 }
7467 {
7468 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
7469 if ( tmp5 == NULL )
7470 return NULL;
7471 Xlen = PyArray_DIMS( tmp5 )[0];
7472 arg6 = Xlen;
7473 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7474 }
7475 {
7476 int i, size;
7477 npy_intp dims[2];
7478 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
7479 if ( tmp7 == NULL )
7480 return NULL;
7481 Ylen = PyArray_DIMS( tmp7 )[0];
7482 arg8 = Ylen;
7483 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7484 // Make created 2D array7 have dimensions from prior ArrayX in the argument
7485 // list and this ArrayY.
7486 dims[0] = Xlen;
7487 dims[1] = Ylen;
7488 array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
7489 if ( !array7 )
7490 return NULL;
7491 size = Ylen;
7492 arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
7493 for ( i = 0; i < Xlen; i++ )
7494 arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7495 }
7496 ecode10 = SWIG_AsVal_int(swig_obj[5], &val10);
7497 if (!SWIG_IsOK(ecode10)) {
7498 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7499 }
7500 arg10 = (PLINT)(val10);
7501 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
7502 if (!SWIG_IsOK(ecode11)) {
7503 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7504 }
7505 arg11 = (PLFLT)(val11);
7506 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7507 resultobj = SWIG_Py_Void();
7508 {
7509 resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
7510 }
7511 {
7512 Py_CLEAR( tmp1 );
7513 }
7514 {
7515 Py_CLEAR( tmp2 );
7516 }
7517 {
7518 Py_CLEAR( tmp3 );
7519 }
7520 {
7521 Py_CLEAR( tmp5 );
7522 }
7523 {
7524 Py_CLEAR( tmp7 );
7525 free( arg9 );
7526 }
7527 return resultobj;
7528fail:
7529 {
7530 Py_CLEAR( tmp1 );
7531 }
7532 {
7533 Py_CLEAR( tmp2 );
7534 }
7535 {
7536 Py_CLEAR( tmp3 );
7537 }
7538 {
7539 Py_CLEAR( tmp5 );
7540 }
7541 {
7542 Py_CLEAR( tmp7 );
7543 free( arg9 );
7544 }
7545 return NULL;
7546}
7547
7548
7549SWIGINTERN PyObject *_wrap_plgspa(PyObject *self, PyObject *args) {
7550 PyObject *resultobj = 0;
7551 PLFLT *arg1 = (PLFLT *) 0 ;
7552 PLFLT *arg2 = (PLFLT *) 0 ;
7553 PLFLT *arg3 = (PLFLT *) 0 ;
7554 PLFLT *arg4 = (PLFLT *) 0 ;
7555 PLFLT temp1 ;
7556 int res1 = SWIG_TMPOBJ ;
7557 PLFLT temp2 ;
7558 int res2 = SWIG_TMPOBJ ;
7559 PLFLT temp3 ;
7560 int res3 = SWIG_TMPOBJ ;
7561 PLFLT temp4 ;
7562 int res4 = SWIG_TMPOBJ ;
7563
7564 arg1 = &temp1;
7565 arg2 = &temp2;
7566 arg3 = &temp3;
7567 arg4 = &temp4;
7568 (void)self;
7569 if (!SWIG_Python_UnpackTuple(args, "plgspa", 0, 0, 0)) SWIG_fail;
7570 plgspa(arg1,arg2,arg3,arg4);
7571 resultobj = SWIG_Py_Void();
7572 if (SWIG_IsTmpObj(res1)) {
7573 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7574 } else {
7575 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7576 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7577 }
7578 if (SWIG_IsTmpObj(res2)) {
7579 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7580 } else {
7581 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7582 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7583 }
7584 if (SWIG_IsTmpObj(res3)) {
7585 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7586 } else {
7587 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7588 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7589 }
7590 if (SWIG_IsTmpObj(res4)) {
7591 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7592 } else {
7593 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7594 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7595 }
7596 return resultobj;
7597fail:
7598 return NULL;
7599}
7600
7601
7602SWIGINTERN PyObject *_wrap_plgstrm(PyObject *self, PyObject *args) {
7603 PyObject *resultobj = 0;
7604 PLINT *arg1 = (PLINT *) 0 ;
7605 PLINT temp1 ;
7606 int res1 = SWIG_TMPOBJ ;
7607
7608 arg1 = &temp1;
7609 (void)self;
7610 if (!SWIG_Python_UnpackTuple(args, "plgstrm", 0, 0, 0)) SWIG_fail;
7611 plgstrm(arg1);
7612 resultobj = SWIG_Py_Void();
7613 if (SWIG_IsTmpObj(res1)) {
7614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7615 } else {
7616 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7618 }
7619 return resultobj;
7620fail:
7621 return NULL;
7622}
7623
7624
7625SWIGINTERN PyObject *_wrap_plgver(PyObject *self, PyObject *args) {
7626 PyObject *resultobj = 0;
7627 char *arg1 = (char *) 0 ;
7628 char buff1[1000] ;
7629
7630 {
7631 arg1 = buff1;
7632 }
7633 (void)self;
7634 if (!SWIG_Python_UnpackTuple(args, "plgver", 0, 0, 0)) SWIG_fail;
7635 plgver(arg1);
7636 resultobj = SWIG_Py_Void();
7637 {
7638 PyObject *o = PyString_FromString( arg1 );
7639 resultobj = t_output_helper( resultobj, o );
7640 }
7641 return resultobj;
7642fail:
7643 return NULL;
7644}
7645
7646
7647SWIGINTERN PyObject *_wrap_plgvpd(PyObject *self, PyObject *args) {
7648 PyObject *resultobj = 0;
7649 PLFLT *arg1 = (PLFLT *) 0 ;
7650 PLFLT *arg2 = (PLFLT *) 0 ;
7651 PLFLT *arg3 = (PLFLT *) 0 ;
7652 PLFLT *arg4 = (PLFLT *) 0 ;
7653 PLFLT temp1 ;
7654 int res1 = SWIG_TMPOBJ ;
7655 PLFLT temp2 ;
7656 int res2 = SWIG_TMPOBJ ;
7657 PLFLT temp3 ;
7658 int res3 = SWIG_TMPOBJ ;
7659 PLFLT temp4 ;
7660 int res4 = SWIG_TMPOBJ ;
7661
7662 arg1 = &temp1;
7663 arg2 = &temp2;
7664 arg3 = &temp3;
7665 arg4 = &temp4;
7666 (void)self;
7667 if (!SWIG_Python_UnpackTuple(args, "plgvpd", 0, 0, 0)) SWIG_fail;
7668 plgvpd(arg1,arg2,arg3,arg4);
7669 resultobj = SWIG_Py_Void();
7670 if (SWIG_IsTmpObj(res1)) {
7671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7672 } else {
7673 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7675 }
7676 if (SWIG_IsTmpObj(res2)) {
7677 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7678 } else {
7679 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7681 }
7682 if (SWIG_IsTmpObj(res3)) {
7683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7684 } else {
7685 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7686 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7687 }
7688 if (SWIG_IsTmpObj(res4)) {
7689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7690 } else {
7691 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7693 }
7694 return resultobj;
7695fail:
7696 return NULL;
7697}
7698
7699
7700SWIGINTERN PyObject *_wrap_plgvpw(PyObject *self, PyObject *args) {
7701 PyObject *resultobj = 0;
7702 PLFLT *arg1 = (PLFLT *) 0 ;
7703 PLFLT *arg2 = (PLFLT *) 0 ;
7704 PLFLT *arg3 = (PLFLT *) 0 ;
7705 PLFLT *arg4 = (PLFLT *) 0 ;
7706 PLFLT temp1 ;
7707 int res1 = SWIG_TMPOBJ ;
7708 PLFLT temp2 ;
7709 int res2 = SWIG_TMPOBJ ;
7710 PLFLT temp3 ;
7711 int res3 = SWIG_TMPOBJ ;
7712 PLFLT temp4 ;
7713 int res4 = SWIG_TMPOBJ ;
7714
7715 arg1 = &temp1;
7716 arg2 = &temp2;
7717 arg3 = &temp3;
7718 arg4 = &temp4;
7719 (void)self;
7720 if (!SWIG_Python_UnpackTuple(args, "plgvpw", 0, 0, 0)) SWIG_fail;
7721 plgvpw(arg1,arg2,arg3,arg4);
7722 resultobj = SWIG_Py_Void();
7723 if (SWIG_IsTmpObj(res1)) {
7724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7725 } else {
7726 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7727 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7728 }
7729 if (SWIG_IsTmpObj(res2)) {
7730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7731 } else {
7732 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7734 }
7735 if (SWIG_IsTmpObj(res3)) {
7736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7737 } else {
7738 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7740 }
7741 if (SWIG_IsTmpObj(res4)) {
7742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7743 } else {
7744 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7746 }
7747 return resultobj;
7748fail:
7749 return NULL;
7750}
7751
7752
7753SWIGINTERN PyObject *_wrap_plgxax(PyObject *self, PyObject *args) {
7754 PyObject *resultobj = 0;
7755 PLINT *arg1 = (PLINT *) 0 ;
7756 PLINT *arg2 = (PLINT *) 0 ;
7757 PLINT temp1 ;
7758 int res1 = SWIG_TMPOBJ ;
7759 PLINT temp2 ;
7760 int res2 = SWIG_TMPOBJ ;
7761
7762 arg1 = &temp1;
7763 arg2 = &temp2;
7764 (void)self;
7765 if (!SWIG_Python_UnpackTuple(args, "plgxax", 0, 0, 0)) SWIG_fail;
7766 plgxax(arg1,arg2);
7767 resultobj = SWIG_Py_Void();
7768 if (SWIG_IsTmpObj(res1)) {
7769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7770 } else {
7771 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7773 }
7774 if (SWIG_IsTmpObj(res2)) {
7775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7776 } else {
7777 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7778 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7779 }
7780 return resultobj;
7781fail:
7782 return NULL;
7783}
7784
7785
7786SWIGINTERN PyObject *_wrap_plgyax(PyObject *self, PyObject *args) {
7787 PyObject *resultobj = 0;
7788 PLINT *arg1 = (PLINT *) 0 ;
7789 PLINT *arg2 = (PLINT *) 0 ;
7790 PLINT temp1 ;
7791 int res1 = SWIG_TMPOBJ ;
7792 PLINT temp2 ;
7793 int res2 = SWIG_TMPOBJ ;
7794
7795 arg1 = &temp1;
7796 arg2 = &temp2;
7797 (void)self;
7798 if (!SWIG_Python_UnpackTuple(args, "plgyax", 0, 0, 0)) SWIG_fail;
7799 plgyax(arg1,arg2);
7800 resultobj = SWIG_Py_Void();
7801 if (SWIG_IsTmpObj(res1)) {
7802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7803 } else {
7804 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7806 }
7807 if (SWIG_IsTmpObj(res2)) {
7808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7809 } else {
7810 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7812 }
7813 return resultobj;
7814fail:
7815 return NULL;
7816}
7817
7818
7819SWIGINTERN PyObject *_wrap_plgzax(PyObject *self, PyObject *args) {
7820 PyObject *resultobj = 0;
7821 PLINT *arg1 = (PLINT *) 0 ;
7822 PLINT *arg2 = (PLINT *) 0 ;
7823 PLINT temp1 ;
7824 int res1 = SWIG_TMPOBJ ;
7825 PLINT temp2 ;
7826 int res2 = SWIG_TMPOBJ ;
7827
7828 arg1 = &temp1;
7829 arg2 = &temp2;
7830 (void)self;
7831 if (!SWIG_Python_UnpackTuple(args, "plgzax", 0, 0, 0)) SWIG_fail;
7832 plgzax(arg1,arg2);
7833 resultobj = SWIG_Py_Void();
7834 if (SWIG_IsTmpObj(res1)) {
7835 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7836 } else {
7837 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7839 }
7840 if (SWIG_IsTmpObj(res2)) {
7841 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7842 } else {
7843 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7844 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7845 }
7846 return resultobj;
7847fail:
7848 return NULL;
7849}
7850
7851
7852SWIGINTERN PyObject *_wrap_plhist(PyObject *self, PyObject *args) {
7853 PyObject *resultobj = 0;
7854 PLINT arg1 ;
7855 PLFLT *arg2 = (PLFLT *) 0 ;
7856 PLFLT arg3 ;
7857 PLFLT arg4 ;
7858 PLINT arg5 ;
7859 PLINT arg6 ;
7860 PyArrayObject *tmp1 = NULL ;
7861 double val3 ;
7862 int ecode3 = 0 ;
7863 double val4 ;
7864 int ecode4 = 0 ;
7865 int val5 ;
7866 int ecode5 = 0 ;
7867 int val6 ;
7868 int ecode6 = 0 ;
7869 PyObject *swig_obj[5] ;
7870
7871 (void)self;
7872 if (!SWIG_Python_UnpackTuple(args, "plhist", 5, 5, swig_obj)) SWIG_fail;
7873 {
7874 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7875 if ( tmp1 == NULL )
7876 return NULL;
7877 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7878 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7879 }
7880 ecode3 = SWIG_AsVal_double(swig_obj[1], &val3);
7881 if (!SWIG_IsOK(ecode3)) {
7882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7883 }
7884 arg3 = (PLFLT)(val3);
7885 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
7886 if (!SWIG_IsOK(ecode4)) {
7887 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7888 }
7889 arg4 = (PLFLT)(val4);
7890 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
7891 if (!SWIG_IsOK(ecode5)) {
7892 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7893 }
7894 arg5 = (PLINT)(val5);
7895 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
7896 if (!SWIG_IsOK(ecode6)) {
7897 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7898 }
7899 arg6 = (PLINT)(val6);
7900 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7901 resultobj = SWIG_Py_Void();
7902 {
7903 Py_CLEAR( tmp1 );
7904 }
7905 return resultobj;
7906fail:
7907 {
7908 Py_CLEAR( tmp1 );
7909 }
7910 return NULL;
7911}
7912
7913
7914SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *self, PyObject *args) {
7915 PyObject *resultobj = 0;
7916 PLFLT arg1 ;
7917 PLFLT arg2 ;
7918 PLFLT arg3 ;
7919 PLFLT *arg4 = (PLFLT *) 0 ;
7920 PLFLT *arg5 = (PLFLT *) 0 ;
7921 PLFLT *arg6 = (PLFLT *) 0 ;
7922 double val1 ;
7923 int ecode1 = 0 ;
7924 double val2 ;
7925 int ecode2 = 0 ;
7926 double val3 ;
7927 int ecode3 = 0 ;
7928 PLFLT temp4 ;
7929 int res4 = SWIG_TMPOBJ ;
7930 PLFLT temp5 ;
7931 int res5 = SWIG_TMPOBJ ;
7932 PLFLT temp6 ;
7933 int res6 = SWIG_TMPOBJ ;
7934 PyObject *swig_obj[3] ;
7935
7936 arg4 = &temp4;
7937 arg5 = &temp5;
7938 arg6 = &temp6;
7939 (void)self;
7940 if (!SWIG_Python_UnpackTuple(args, "plhlsrgb", 3, 3, swig_obj)) SWIG_fail;
7941 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7942 if (!SWIG_IsOK(ecode1)) {
7943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7944 }
7945 arg1 = (PLFLT)(val1);
7946 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7947 if (!SWIG_IsOK(ecode2)) {
7948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7949 }
7950 arg2 = (PLFLT)(val2);
7951 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7952 if (!SWIG_IsOK(ecode3)) {
7953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7954 }
7955 arg3 = (PLFLT)(val3);
7956 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7957 resultobj = SWIG_Py_Void();
7958 if (SWIG_IsTmpObj(res4)) {
7959 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7960 } else {
7961 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7962 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7963 }
7964 if (SWIG_IsTmpObj(res5)) {
7965 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7966 } else {
7967 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7969 }
7970 if (SWIG_IsTmpObj(res6)) {
7971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7972 } else {
7973 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7975 }
7976 return resultobj;
7977fail:
7978 return NULL;
7979}
7980
7981
7982SWIGINTERN PyObject *_wrap_plinit(PyObject *self, PyObject *args) {
7983 PyObject *resultobj = 0;
7984
7985 (void)self;
7986 if (!SWIG_Python_UnpackTuple(args, "plinit", 0, 0, 0)) SWIG_fail;
7987 plinit();
7988 resultobj = SWIG_Py_Void();
7989 return resultobj;
7990fail:
7991 return NULL;
7992}
7993
7994
7995SWIGINTERN PyObject *_wrap_pljoin(PyObject *self, PyObject *args) {
7996 PyObject *resultobj = 0;
7997 PLFLT arg1 ;
7998 PLFLT arg2 ;
7999 PLFLT arg3 ;
8000 PLFLT arg4 ;
8001 double val1 ;
8002 int ecode1 = 0 ;
8003 double val2 ;
8004 int ecode2 = 0 ;
8005 double val3 ;
8006 int ecode3 = 0 ;
8007 double val4 ;
8008 int ecode4 = 0 ;
8009 PyObject *swig_obj[4] ;
8010
8011 (void)self;
8012 if (!SWIG_Python_UnpackTuple(args, "pljoin", 4, 4, swig_obj)) SWIG_fail;
8013 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8014 if (!SWIG_IsOK(ecode1)) {
8015 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
8016 }
8017 arg1 = (PLFLT)(val1);
8018 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8019 if (!SWIG_IsOK(ecode2)) {
8020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
8021 }
8022 arg2 = (PLFLT)(val2);
8023 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8024 if (!SWIG_IsOK(ecode3)) {
8025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
8026 }
8027 arg3 = (PLFLT)(val3);
8028 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8029 if (!SWIG_IsOK(ecode4)) {
8030 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
8031 }
8032 arg4 = (PLFLT)(val4);
8033 pljoin(arg1,arg2,arg3,arg4);
8034 resultobj = SWIG_Py_Void();
8035 return resultobj;
8036fail:
8037 return NULL;
8038}
8039
8040
8041SWIGINTERN PyObject *_wrap_pllab(PyObject *self, PyObject *args) {
8042 PyObject *resultobj = 0;
8043 char *arg1 = (char *) 0 ;
8044 char *arg2 = (char *) 0 ;
8045 char *arg3 = (char *) 0 ;
8046 int res1 ;
8047 char *buf1 = 0 ;
8048 int alloc1 = 0 ;
8049 int res2 ;
8050 char *buf2 = 0 ;
8051 int alloc2 = 0 ;
8052 int res3 ;
8053 char *buf3 = 0 ;
8054 int alloc3 = 0 ;
8055 PyObject *swig_obj[3] ;
8056
8057 (void)self;
8058 if (!SWIG_Python_UnpackTuple(args, "pllab", 3, 3, swig_obj)) SWIG_fail;
8059 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8060 if (!SWIG_IsOK(res1)) {
8061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
8062 }
8063 arg1 = (char *)(buf1);
8064 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
8065 if (!SWIG_IsOK(res2)) {
8066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
8067 }
8068 arg2 = (char *)(buf2);
8069 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
8070 if (!SWIG_IsOK(res3)) {
8071 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
8072 }
8073 arg3 = (char *)(buf3);
8074 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
8075 resultobj = SWIG_Py_Void();
8076 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8077 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8078 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8079 return resultobj;
8080fail:
8081 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8082 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8083 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8084 return NULL;
8085}
8086
8087
8088SWIGINTERN PyObject *_wrap_pllegend(PyObject *self, PyObject *args) {
8089 PyObject *resultobj = 0;
8090 PLFLT *arg1 = (PLFLT *) 0 ;
8091 PLFLT *arg2 = (PLFLT *) 0 ;
8092 PLINT arg3 ;
8093 PLINT arg4 ;
8094 PLFLT arg5 ;
8095 PLFLT arg6 ;
8096 PLFLT arg7 ;
8097 PLINT arg8 ;
8098 PLINT arg9 ;
8099 PLINT arg10 ;
8100 PLINT arg11 ;
8101 PLINT arg12 ;
8102 PLINT arg13 ;
8103 PLINT *arg14 = (PLINT *) 0 ;
8104 PLFLT arg15 ;
8105 PLFLT arg16 ;
8106 PLFLT arg17 ;
8107 PLFLT arg18 ;
8108 PLINT *arg19 = (PLINT *) 0 ;
8109 char **arg20 = (char **) 0 ;
8110 PLINT *arg21 = (PLINT *) 0 ;
8111 PLINT *arg22 = (PLINT *) 0 ;
8112 PLFLT *arg23 = (PLFLT *) 0 ;
8113 PLFLT *arg24 = (PLFLT *) 0 ;
8114 PLINT *arg25 = (PLINT *) 0 ;
8115 PLINT *arg26 = (PLINT *) 0 ;
8116 PLFLT *arg27 = (PLFLT *) 0 ;
8117 PLINT *arg28 = (PLINT *) 0 ;
8118 PLFLT *arg29 = (PLFLT *) 0 ;
8119 PLINT *arg30 = (PLINT *) 0 ;
8120 char **arg31 = (char **) 0 ;
8121 PLFLT temp1 ;
8122 int res1 = SWIG_TMPOBJ ;
8123 PLFLT temp2 ;
8124 int res2 = SWIG_TMPOBJ ;
8125 int val3 ;
8126 int ecode3 = 0 ;
8127 int val4 ;
8128 int ecode4 = 0 ;
8129 double val5 ;
8130 int ecode5 = 0 ;
8131 double val6 ;
8132 int ecode6 = 0 ;
8133 double val7 ;
8134 int ecode7 = 0 ;
8135 int val8 ;
8136 int ecode8 = 0 ;
8137 int val9 ;
8138 int ecode9 = 0 ;
8139 int val10 ;
8140 int ecode10 = 0 ;
8141 int val11 ;
8142 int ecode11 = 0 ;
8143 int val12 ;
8144 int ecode12 = 0 ;
8145 PyArrayObject *tmp13 = NULL ;
8146 double val15 ;
8147 int ecode15 = 0 ;
8148 double val16 ;
8149 int ecode16 = 0 ;
8150 double val17 ;
8151 int ecode17 = 0 ;
8152 double val18 ;
8153 int ecode18 = 0 ;
8154 PyArrayObject *tmp19 = NULL ;
8155 PyArrayObject *tmp20 = NULL ;
8156 PyArrayObject *tmp21 = NULL ;
8157 PyArrayObject *tmp22 = NULL ;
8158 PyArrayObject *tmp23 = NULL ;
8159 PyArrayObject *tmp24 = NULL ;
8160 PyArrayObject *tmp25 = NULL ;
8161 PyArrayObject *tmp26 = NULL ;
8162 PyArrayObject *tmp27 = NULL ;
8163 PyArrayObject *tmp28 = NULL ;
8164 PyArrayObject *tmp29 = NULL ;
8165 PyArrayObject *tmp30 = NULL ;
8166 PyArrayObject *tmp31 = NULL ;
8167 PyObject *swig_obj[28] ;
8168
8169 arg1 = &temp1;
8170 arg2 = &temp2;
8171 (void)self;
8172 if (!SWIG_Python_UnpackTuple(args, "pllegend", 28, 28, swig_obj)) SWIG_fail;
8173 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8174 if (!SWIG_IsOK(ecode3)) {
8175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
8176 }
8177 arg3 = (PLINT)(val3);
8178 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8179 if (!SWIG_IsOK(ecode4)) {
8180 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
8181 }
8182 arg4 = (PLINT)(val4);
8183 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8184 if (!SWIG_IsOK(ecode5)) {
8185 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
8186 }
8187 arg5 = (PLFLT)(val5);
8188 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8189 if (!SWIG_IsOK(ecode6)) {
8190 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
8191 }
8192 arg6 = (PLFLT)(val6);
8193 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8194 if (!SWIG_IsOK(ecode7)) {
8195 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
8196 }
8197 arg7 = (PLFLT)(val7);
8198 ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
8199 if (!SWIG_IsOK(ecode8)) {
8200 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
8201 }
8202 arg8 = (PLINT)(val8);
8203 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8204 if (!SWIG_IsOK(ecode9)) {
8205 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
8206 }
8207 arg9 = (PLINT)(val9);
8208 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8209 if (!SWIG_IsOK(ecode10)) {
8210 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
8211 }
8212 arg10 = (PLINT)(val10);
8213 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8214 if (!SWIG_IsOK(ecode11)) {
8215 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
8216 }
8217 arg11 = (PLINT)(val11);
8218 ecode12 = SWIG_AsVal_int(swig_obj[9], &val12);
8219 if (!SWIG_IsOK(ecode12)) {
8220 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
8221 }
8222 arg12 = (PLINT)(val12);
8223 {
8224 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[10], NPY_PLINT, 1, 1 );
8225 if ( tmp13 == NULL )
8226 return NULL;
8227 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
8228 arg14 = (PLINT *) PyArray_DATA( tmp13 );
8229 }
8230 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
8231 if (!SWIG_IsOK(ecode15)) {
8232 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
8233 }
8234 arg15 = (PLFLT)(val15);
8235 ecode16 = SWIG_AsVal_double(swig_obj[12], &val16);
8236 if (!SWIG_IsOK(ecode16)) {
8237 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
8238 }
8239 arg16 = (PLFLT)(val16);
8240 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
8241 if (!SWIG_IsOK(ecode17)) {
8242 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
8243 }
8244 arg17 = (PLFLT)(val17);
8245 ecode18 = SWIG_AsVal_double(swig_obj[14], &val18);
8246 if (!SWIG_IsOK(ecode18)) {
8247 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
8248 }
8249 arg18 = (PLFLT)(val18);
8250 {
8251 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[15], NPY_PLINT, 1, 1 );
8252 if ( tmp19 == NULL )
8253 return NULL;
8254 if ( PyArray_DIMS( tmp19 )[0] != Alen )
8255 {
8256 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8257 return NULL;
8258 }
8259 arg19 = (PLINT *) PyArray_DATA( tmp19 );
8260 }
8261 {
8262 int i;
8263 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[16], NPY_STRING, 1, 1 );
8264 if ( tmp20 == NULL )
8265 return NULL;
8266 if ( PyArray_DIMS( tmp20 )[0] != Alen )
8267 {
8268 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8269 return NULL;
8270 }
8271 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8272 for ( i = 0; i < Alen; i++ )
8273 {
8274 arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8275 if ( arg20[i] == NULL )
8276 {
8277 free( arg20 );
8278 return NULL;
8279 }
8280 }
8281 }
8282 {
8283 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8284 if ( tmp21 == NULL )
8285 return NULL;
8286 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8287 {
8288 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8289 return NULL;
8290 }
8291 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8292 }
8293 {
8294 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8295 if ( tmp22 == NULL )
8296 return NULL;
8297 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8298 {
8299 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8300 return NULL;
8301 }
8302 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8303 }
8304 {
8305 if ( swig_obj[19] != Py_None )
8306 {
8307 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 1, 1 );
8308 if ( tmp23 == NULL )
8309 return NULL;
8310 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8311 {
8312 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8313 return NULL;
8314 }
8315 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8316 }
8317 else
8318 {
8319 arg23 = NULL;
8320 }
8321 }
8322 {
8323 if ( swig_obj[20] != Py_None )
8324 {
8325 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[20], NPY_PLFLT, 1, 1 );
8326 if ( tmp24 == NULL )
8327 return NULL;
8328 if ( PyArray_DIMS( tmp24 )[0] != Alen )
8329 {
8330 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8331 return NULL;
8332 }
8333 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8334 }
8335 else
8336 {
8337 arg24 = NULL;
8338 }
8339 }
8340 {
8341 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[21], NPY_PLINT, 1, 1 );
8342 if ( tmp25 == NULL )
8343 return NULL;
8344 if ( PyArray_DIMS( tmp25 )[0] != Alen )
8345 {
8346 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8347 return NULL;
8348 }
8349 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8350 }
8351 {
8352 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[22], NPY_PLINT, 1, 1 );
8353 if ( tmp26 == NULL )
8354 return NULL;
8355 if ( PyArray_DIMS( tmp26 )[0] != Alen )
8356 {
8357 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8358 return NULL;
8359 }
8360 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8361 }
8362 {
8363 if ( swig_obj[23] != Py_None )
8364 {
8365 tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[23], NPY_PLFLT, 1, 1 );
8366 if ( tmp27 == NULL )
8367 return NULL;
8368 if ( PyArray_DIMS( tmp27 )[0] != Alen )
8369 {
8370 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8371 return NULL;
8372 }
8373 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8374 }
8375 else
8376 {
8377 arg27 = NULL;
8378 }
8379 }
8380 {
8381 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[24], NPY_PLINT, 1, 1 );
8382 if ( tmp28 == NULL )
8383 return NULL;
8384 if ( PyArray_DIMS( tmp28 )[0] != Alen )
8385 {
8386 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8387 return NULL;
8388 }
8389 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8390 }
8391 {
8392 if ( swig_obj[25] != Py_None )
8393 {
8394 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[25], NPY_PLFLT, 1, 1 );
8395 if ( tmp29 == NULL )
8396 return NULL;
8397 if ( PyArray_DIMS( tmp29 )[0] != Alen )
8398 {
8399 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8400 return NULL;
8401 }
8402 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8403 }
8404 else
8405 {
8406 arg29 = NULL;
8407 }
8408 }
8409 {
8410 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[26], NPY_PLINT, 1, 1 );
8411 if ( tmp30 == NULL )
8412 return NULL;
8413 if ( PyArray_DIMS( tmp30 )[0] != Alen )
8414 {
8415 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8416 return NULL;
8417 }
8418 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8419 }
8420 {
8421 int i;
8422 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[27], NPY_STRING, 1, 1 );
8423 if ( tmp31 == NULL )
8424 return NULL;
8425 if ( PyArray_DIMS( tmp31 )[0] != Alen )
8426 {
8427 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8428 return NULL;
8429 }
8430 arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8431 for ( i = 0; i < Alen; i++ )
8432 {
8433 arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8434 if ( arg31[i] == NULL )
8435 {
8436 free( arg31 );
8437 return NULL;
8438 }
8439 }
8440 }
8441 pllegend(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(int const *)arg14,arg15,arg16,arg17,arg18,(int const *)arg19,(char const **)arg20,(int const *)arg21,(int const *)arg22,(double const *)arg23,(double const *)arg24,(int const *)arg25,(int const *)arg26,(double const *)arg27,(int const *)arg28,(double const *)arg29,(int const *)arg30,(char const **)arg31);
8442 resultobj = SWIG_Py_Void();
8443 if (SWIG_IsTmpObj(res1)) {
8444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8445 } else {
8446 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8448 }
8449 if (SWIG_IsTmpObj(res2)) {
8450 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8451 } else {
8452 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8453 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8454 }
8455 {
8456 Py_CLEAR( tmp13 );
8457 }
8458 {
8459 Py_CLEAR( tmp19 );
8460 }
8461 {
8462 Py_CLEAR( tmp20 ); free( arg20 );
8463 }
8464 {
8465 Py_CLEAR( tmp21 );
8466 }
8467 {
8468 Py_CLEAR( tmp22 );
8469 }
8470 {
8471 Py_CLEAR( tmp23 );
8472 }
8473 {
8474 Py_CLEAR( tmp24 );
8475 }
8476 {
8477 Py_CLEAR( tmp25 );
8478 }
8479 {
8480 Py_CLEAR( tmp26 );
8481 }
8482 {
8483 Py_CLEAR( tmp27 );
8484 }
8485 {
8486 Py_CLEAR( tmp28 );
8487 }
8488 {
8489 Py_CLEAR( tmp29 );
8490 }
8491 {
8492 Py_CLEAR( tmp30 );
8493 }
8494 {
8495 Py_CLEAR( tmp31 ); free( arg31 );
8496 }
8497 return resultobj;
8498fail:
8499 {
8500 Py_CLEAR( tmp13 );
8501 }
8502 {
8503 Py_CLEAR( tmp19 );
8504 }
8505 {
8506 Py_CLEAR( tmp20 ); free( arg20 );
8507 }
8508 {
8509 Py_CLEAR( tmp21 );
8510 }
8511 {
8512 Py_CLEAR( tmp22 );
8513 }
8514 {
8515 Py_CLEAR( tmp23 );
8516 }
8517 {
8518 Py_CLEAR( tmp24 );
8519 }
8520 {
8521 Py_CLEAR( tmp25 );
8522 }
8523 {
8524 Py_CLEAR( tmp26 );
8525 }
8526 {
8527 Py_CLEAR( tmp27 );
8528 }
8529 {
8530 Py_CLEAR( tmp28 );
8531 }
8532 {
8533 Py_CLEAR( tmp29 );
8534 }
8535 {
8536 Py_CLEAR( tmp30 );
8537 }
8538 {
8539 Py_CLEAR( tmp31 ); free( arg31 );
8540 }
8541 return NULL;
8542}
8543
8544
8545SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *self, PyObject *args) {
8546 PyObject *resultobj = 0;
8547 PLFLT *arg1 = (PLFLT *) 0 ;
8548 PLFLT *arg2 = (PLFLT *) 0 ;
8549 PLINT arg3 ;
8550 PLINT arg4 ;
8551 PLFLT arg5 ;
8552 PLFLT arg6 ;
8553 PLFLT arg7 ;
8554 PLFLT arg8 ;
8555 PLINT arg9 ;
8556 PLINT arg10 ;
8557 PLINT arg11 ;
8558 PLFLT arg12 ;
8559 PLFLT arg13 ;
8560 PLINT arg14 ;
8561 PLFLT arg15 ;
8562 PLINT arg16 ;
8563 PLINT *arg17 = (PLINT *) 0 ;
8564 char **arg18 = (char **) 0 ;
8565 PLINT arg19 ;
8566 char **arg20 = (char **) 0 ;
8567 PLFLT *arg21 = (PLFLT *) 0 ;
8568 PLINT *arg22 = (PLINT *) 0 ;
8569 PLINT *arg23 = (PLINT *) 0 ;
8570 PLFLT **arg24 = (PLFLT **) 0 ;
8571 PLFLT temp1 ;
8572 int res1 = SWIG_TMPOBJ ;
8573 PLFLT temp2 ;
8574 int res2 = SWIG_TMPOBJ ;
8575 int val3 ;
8576 int ecode3 = 0 ;
8577 int val4 ;
8578 int ecode4 = 0 ;
8579 double val5 ;
8580 int ecode5 = 0 ;
8581 double val6 ;
8582 int ecode6 = 0 ;
8583 double val7 ;
8584 int ecode7 = 0 ;
8585 double val8 ;
8586 int ecode8 = 0 ;
8587 int val9 ;
8588 int ecode9 = 0 ;
8589 int val10 ;
8590 int ecode10 = 0 ;
8591 int val11 ;
8592 int ecode11 = 0 ;
8593 double val12 ;
8594 int ecode12 = 0 ;
8595 double val13 ;
8596 int ecode13 = 0 ;
8597 int val14 ;
8598 int ecode14 = 0 ;
8599 double val15 ;
8600 int ecode15 = 0 ;
8601 PyArrayObject *tmp16 = NULL ;
8602 PyArrayObject *tmp18 = NULL ;
8603 PyArrayObject *tmp19 = NULL ;
8604 PyArrayObject *tmp21 = NULL ;
8605 PyArrayObject *tmp22 = NULL ;
8606 PyArrayObject *tmp23 = NULL ;
8607 PyArrayObject *tmp24 = NULL ;
8608 PyObject *swig_obj[20] ;
8609
8610 arg1 = &temp1;
8611 arg2 = &temp2;
8612 (void)self;
8613 if (!SWIG_Python_UnpackTuple(args, "plcolorbar", 20, 20, swig_obj)) SWIG_fail;
8614 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8615 if (!SWIG_IsOK(ecode3)) {
8616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8617 }
8618 arg3 = (PLINT)(val3);
8619 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8620 if (!SWIG_IsOK(ecode4)) {
8621 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8622 }
8623 arg4 = (PLINT)(val4);
8624 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8625 if (!SWIG_IsOK(ecode5)) {
8626 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8627 }
8628 arg5 = (PLFLT)(val5);
8629 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8630 if (!SWIG_IsOK(ecode6)) {
8631 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8632 }
8633 arg6 = (PLFLT)(val6);
8634 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8635 if (!SWIG_IsOK(ecode7)) {
8636 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8637 }
8638 arg7 = (PLFLT)(val7);
8639 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
8640 if (!SWIG_IsOK(ecode8)) {
8641 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8642 }
8643 arg8 = (PLFLT)(val8);
8644 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8645 if (!SWIG_IsOK(ecode9)) {
8646 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8647 }
8648 arg9 = (PLINT)(val9);
8649 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8650 if (!SWIG_IsOK(ecode10)) {
8651 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8652 }
8653 arg10 = (PLINT)(val10);
8654 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8655 if (!SWIG_IsOK(ecode11)) {
8656 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8657 }
8658 arg11 = (PLINT)(val11);
8659 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
8660 if (!SWIG_IsOK(ecode12)) {
8661 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8662 }
8663 arg12 = (PLFLT)(val12);
8664 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
8665 if (!SWIG_IsOK(ecode13)) {
8666 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8667 }
8668 arg13 = (PLFLT)(val13);
8669 ecode14 = SWIG_AsVal_int(swig_obj[11], &val14);
8670 if (!SWIG_IsOK(ecode14)) {
8671 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8672 }
8673 arg14 = (PLINT)(val14);
8674 ecode15 = SWIG_AsVal_double(swig_obj[12], &val15);
8675 if (!SWIG_IsOK(ecode15)) {
8676 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8677 }
8678 arg15 = (PLFLT)(val15);
8679 {
8680 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
8681 if ( tmp16 == NULL )
8682 return NULL;
8683 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8684 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8685 }
8686 {
8687 int i;
8688 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[14], NPY_STRING, 1, 1 );
8689 if ( tmp18 == NULL )
8690 return NULL;
8691 if ( PyArray_DIMS( tmp18 )[0] != Alen )
8692 {
8693 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8694 return NULL;
8695 }
8696 arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8697 for ( i = 0; i < Alen; i++ )
8698 {
8699 arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8700 if ( arg18[i] == NULL )
8701 {
8702 free( arg18 );
8703 return NULL;
8704 }
8705 }
8706 }
8707 {
8708 int i;
8709 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[15], NPY_STRING, 1, 1 );
8710 if ( tmp19 == NULL )
8711 return NULL;
8712 Alen = PyArray_DIMS( tmp19 )[0];
8713 arg19 = Alen;
8714 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8715 for ( i = 0; i < Alen; i++ )
8716 {
8717 arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8718 if ( arg20[i] == NULL )
8719 {
8720 free( arg20 );
8721 return NULL;
8722 }
8723 }
8724 }
8725 {
8726 tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[16], NPY_PLFLT, 1, 1 );
8727 if ( tmp21 == NULL )
8728 return NULL;
8729 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8730 {
8731 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8732 return NULL;
8733 }
8734 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8735 }
8736 {
8737 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8738 if ( tmp22 == NULL )
8739 return NULL;
8740 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8741 {
8742 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8743 return NULL;
8744 }
8745 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8746 }
8747 {
8748 int i;
8749 tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8750 if ( tmp23 == NULL )
8751 return NULL;
8752 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8753 {
8754 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8755 return NULL;
8756 }
8757 Xlen = PyArray_DIMS( tmp23 )[0];
8758 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8759 Ylen = -1;
8760 for ( i = 0; i < Xlen; i++ )
8761 if ( arg23[i] > Ylen )
8762 Ylen = arg23[i];
8763 }
8764 {
8765 int i, size;
8766 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 2, 2 );
8767 if ( tmp24 == NULL )
8768 return NULL;
8769 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8770 {
8771 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8772 return NULL;
8773 }
8774 size = Ylen;
8775 arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8776 for ( i = 0; i < Xlen; i++ )
8777 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8778 }
8779 plcolorbar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,(int const *)arg17,(char const **)arg18,arg19,(char const **)arg20,(double const *)arg21,(int const *)arg22,(int const *)arg23,(double const **)arg24);
8780 resultobj = SWIG_Py_Void();
8781 if (SWIG_IsTmpObj(res1)) {
8782 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8783 } else {
8784 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8785 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8786 }
8787 if (SWIG_IsTmpObj(res2)) {
8788 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8789 } else {
8790 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8792 }
8793 {
8794 Py_CLEAR( tmp16 );
8795 }
8796 {
8797 Py_CLEAR( tmp18 ); free( arg18 );
8798 }
8799 {
8800 Py_CLEAR( tmp19 ); free( arg20 );
8801 }
8802 {
8803 Py_CLEAR( tmp21 );
8804 }
8805 {
8806 Py_CLEAR( tmp22 );
8807 }
8808 {
8809 Py_CLEAR( tmp23 );
8810 }
8811 {
8812 Py_CLEAR( tmp24 );
8813 free( arg24 );
8814 }
8815 return resultobj;
8816fail:
8817 {
8818 Py_CLEAR( tmp16 );
8819 }
8820 {
8821 Py_CLEAR( tmp18 ); free( arg18 );
8822 }
8823 {
8824 Py_CLEAR( tmp19 ); free( arg20 );
8825 }
8826 {
8827 Py_CLEAR( tmp21 );
8828 }
8829 {
8830 Py_CLEAR( tmp22 );
8831 }
8832 {
8833 Py_CLEAR( tmp23 );
8834 }
8835 {
8836 Py_CLEAR( tmp24 );
8837 free( arg24 );
8838 }
8839 return NULL;
8840}
8841
8842
8843SWIGINTERN PyObject *_wrap_pllightsource(PyObject *self, PyObject *args) {
8844 PyObject *resultobj = 0;
8845 PLFLT arg1 ;
8846 PLFLT arg2 ;
8847 PLFLT arg3 ;
8848 double val1 ;
8849 int ecode1 = 0 ;
8850 double val2 ;
8851 int ecode2 = 0 ;
8852 double val3 ;
8853 int ecode3 = 0 ;
8854 PyObject *swig_obj[3] ;
8855
8856 (void)self;
8857 if (!SWIG_Python_UnpackTuple(args, "pllightsource", 3, 3, swig_obj)) SWIG_fail;
8858 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8859 if (!SWIG_IsOK(ecode1)) {
8860 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8861 }
8862 arg1 = (PLFLT)(val1);
8863 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8864 if (!SWIG_IsOK(ecode2)) {
8865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8866 }
8867 arg2 = (PLFLT)(val2);
8868 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8869 if (!SWIG_IsOK(ecode3)) {
8870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8871 }
8872 arg3 = (PLFLT)(val3);
8873 pllightsource(arg1,arg2,arg3);
8874 resultobj = SWIG_Py_Void();
8875 return resultobj;
8876fail:
8877 return NULL;
8878}
8879
8880
8881SWIGINTERN PyObject *_wrap_plline(PyObject *self, PyObject *args) {
8882 PyObject *resultobj = 0;
8883 PLINT arg1 ;
8884 PLFLT *arg2 = (PLFLT *) 0 ;
8885 PLFLT *arg3 = (PLFLT *) 0 ;
8886 PyArrayObject *tmp1 = NULL ;
8887 PyArrayObject *tmp3 = NULL ;
8888 PyObject *swig_obj[2] ;
8889
8890 (void)self;
8891 if (!SWIG_Python_UnpackTuple(args, "plline", 2, 2, swig_obj)) SWIG_fail;
8892 {
8893 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8894 if ( tmp1 == NULL )
8895 return NULL;
8896 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8897 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8898 }
8899 {
8900 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8901 if ( tmp3 == NULL )
8902 return NULL;
8903 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8904 {
8905 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8906 return NULL;
8907 }
8908 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8909 }
8910 plline(arg1,(double const *)arg2,(double const *)arg3);
8911 resultobj = SWIG_Py_Void();
8912 {
8913 Py_CLEAR( tmp1 );
8914 }
8915 {
8916 Py_CLEAR( tmp3 );
8917 }
8918 return resultobj;
8919fail:
8920 {
8921 Py_CLEAR( tmp1 );
8922 }
8923 {
8924 Py_CLEAR( tmp3 );
8925 }
8926 return NULL;
8927}
8928
8929
8930SWIGINTERN PyObject *_wrap_plline3(PyObject *self, PyObject *args) {
8931 PyObject *resultobj = 0;
8932 PLINT arg1 ;
8933 PLFLT *arg2 = (PLFLT *) 0 ;
8934 PLFLT *arg3 = (PLFLT *) 0 ;
8935 PLFLT *arg4 = (PLFLT *) 0 ;
8936 PyArrayObject *tmp1 = NULL ;
8937 PyArrayObject *tmp3 = NULL ;
8938 PyArrayObject *tmp4 = NULL ;
8939 PyObject *swig_obj[3] ;
8940
8941 (void)self;
8942 if (!SWIG_Python_UnpackTuple(args, "plline3", 3, 3, swig_obj)) SWIG_fail;
8943 {
8944 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8945 if ( tmp1 == NULL )
8946 return NULL;
8947 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8948 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8949 }
8950 {
8951 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8952 if ( tmp3 == NULL )
8953 return NULL;
8954 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8955 {
8956 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8957 return NULL;
8958 }
8959 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8960 }
8961 {
8962 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
8963 if ( tmp4 == NULL )
8964 return NULL;
8965 if ( PyArray_DIMS( tmp4 )[0] != Alen )
8966 {
8967 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8968 return NULL;
8969 }
8970 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8971 }
8972 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8973 resultobj = SWIG_Py_Void();
8974 {
8975 Py_CLEAR( tmp1 );
8976 }
8977 {
8978 Py_CLEAR( tmp3 );
8979 }
8980 {
8981 Py_CLEAR( tmp4 );
8982 }
8983 return resultobj;
8984fail:
8985 {
8986 Py_CLEAR( tmp1 );
8987 }
8988 {
8989 Py_CLEAR( tmp3 );
8990 }
8991 {
8992 Py_CLEAR( tmp4 );
8993 }
8994 return NULL;
8995}
8996
8997
8998SWIGINTERN PyObject *_wrap_pllsty(PyObject *self, PyObject *args) {
8999 PyObject *resultobj = 0;
9000 PLINT arg1 ;
9001 int val1 ;
9002 int ecode1 = 0 ;
9003 PyObject *swig_obj[1] ;
9004
9005 (void)self;
9006 if (!args) SWIG_fail;
9007 swig_obj[0] = args;
9008 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9009 if (!SWIG_IsOK(ecode1)) {
9010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
9011 }
9012 arg1 = (PLINT)(val1);
9013 pllsty(arg1);
9014 resultobj = SWIG_Py_Void();
9015 return resultobj;
9016fail:
9017 return NULL;
9018}
9019
9020
9021SWIGINTERN PyObject *_wrap_plmesh(PyObject *self, PyObject *args) {
9022 PyObject *resultobj = 0;
9023 PLFLT *arg1 = (PLFLT *) 0 ;
9024 PLFLT *arg2 = (PLFLT *) 0 ;
9025 PLFLT **arg3 = (PLFLT **) 0 ;
9026 PLINT arg4 ;
9027 PLINT arg5 ;
9028 PLINT arg6 ;
9029 PyArrayObject *tmp1 = NULL ;
9030 PyArrayObject *tmp2 = NULL ;
9031 PyArrayObject *tmp3 = NULL ;
9032 int val6 ;
9033 int ecode6 = 0 ;
9034 PyObject *swig_obj[4] ;
9035
9036 (void)self;
9037 if (!SWIG_Python_UnpackTuple(args, "plmesh", 4, 4, swig_obj)) SWIG_fail;
9038 {
9039 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9040 if ( tmp1 == NULL )
9041 return NULL;
9042 Xlen = PyArray_DIMS( tmp1 )[0];
9043 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9044 }
9045 {
9046 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9047 if ( tmp2 == NULL )
9048 return NULL;
9049 Ylen = PyArray_DIMS( tmp2 )[0];
9050 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9051 }
9052 {
9053 int i, size;
9054 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9055 if ( tmp3 == NULL )
9056 return NULL;
9057 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9058 {
9059 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9060 return NULL;
9061 }
9062 arg4 = PyArray_DIMS( tmp3 )[0];
9063 arg5 = PyArray_DIMS( tmp3 )[1];
9064 size = arg5;
9065 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9066 for ( i = 0; i < arg4; i++ )
9067 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9068 }
9069 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9070 if (!SWIG_IsOK(ecode6)) {
9071 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
9072 }
9073 arg6 = (PLINT)(val6);
9074 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
9075 resultobj = SWIG_Py_Void();
9076 {
9077 Py_CLEAR( tmp1 );
9078 }
9079 {
9080 Py_CLEAR( tmp2 );
9081 }
9082 {
9083 Py_CLEAR( tmp3 );
9084 free( arg3 );
9085 }
9086 return resultobj;
9087fail:
9088 {
9089 Py_CLEAR( tmp1 );
9090 }
9091 {
9092 Py_CLEAR( tmp2 );
9093 }
9094 {
9095 Py_CLEAR( tmp3 );
9096 free( arg3 );
9097 }
9098 return NULL;
9099}
9100
9101
9102SWIGINTERN PyObject *_wrap_plmeshc(PyObject *self, PyObject *args) {
9103 PyObject *resultobj = 0;
9104 PLFLT *arg1 = (PLFLT *) 0 ;
9105 PLFLT *arg2 = (PLFLT *) 0 ;
9106 PLFLT **arg3 = (PLFLT **) 0 ;
9107 PLINT arg4 ;
9108 PLINT arg5 ;
9109 PLINT arg6 ;
9110 PLFLT *arg7 = (PLFLT *) 0 ;
9111 PLINT arg8 ;
9112 PyArrayObject *tmp1 = NULL ;
9113 PyArrayObject *tmp2 = NULL ;
9114 PyArrayObject *tmp3 = NULL ;
9115 int val6 ;
9116 int ecode6 = 0 ;
9117 PyArrayObject *tmp7 = NULL ;
9118 PyObject *swig_obj[5] ;
9119
9120 (void)self;
9121 if (!SWIG_Python_UnpackTuple(args, "plmeshc", 5, 5, swig_obj)) SWIG_fail;
9122 {
9123 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9124 if ( tmp1 == NULL )
9125 return NULL;
9126 Xlen = PyArray_DIMS( tmp1 )[0];
9127 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9128 }
9129 {
9130 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9131 if ( tmp2 == NULL )
9132 return NULL;
9133 Ylen = PyArray_DIMS( tmp2 )[0];
9134 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9135 }
9136 {
9137 int i, size;
9138 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9139 if ( tmp3 == NULL )
9140 return NULL;
9141 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9142 {
9143 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9144 return NULL;
9145 }
9146 arg4 = PyArray_DIMS( tmp3 )[0];
9147 arg5 = PyArray_DIMS( tmp3 )[1];
9148 size = arg5;
9149 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9150 for ( i = 0; i < arg4; i++ )
9151 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9152 }
9153 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9154 if (!SWIG_IsOK(ecode6)) {
9155 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9156 }
9157 arg6 = (PLINT)(val6);
9158 {
9159 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9160 if ( tmp7 == NULL )
9161 return NULL;
9162 arg8 = PyArray_DIMS( tmp7 )[0];
9163 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9164 }
9165 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9166 resultobj = SWIG_Py_Void();
9167 {
9168 Py_CLEAR( tmp1 );
9169 }
9170 {
9171 Py_CLEAR( tmp2 );
9172 }
9173 {
9174 Py_CLEAR( tmp3 );
9175 free( arg3 );
9176 }
9177 {
9178 Py_CLEAR( tmp7 );
9179 }
9180 return resultobj;
9181fail:
9182 {
9183 Py_CLEAR( tmp1 );
9184 }
9185 {
9186 Py_CLEAR( tmp2 );
9187 }
9188 {
9189 Py_CLEAR( tmp3 );
9190 free( arg3 );
9191 }
9192 {
9193 Py_CLEAR( tmp7 );
9194 }
9195 return NULL;
9196}
9197
9198
9199SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *self, PyObject *args) {
9200 PyObject *resultobj = 0;
9201 PLINT *arg1 = (PLINT *) 0 ;
9202 PLINT temp1 ;
9203 int res1 = SWIG_TMPOBJ ;
9204
9205 arg1 = &temp1;
9206 (void)self;
9207 if (!SWIG_Python_UnpackTuple(args, "plmkstrm", 0, 0, 0)) SWIG_fail;
9208 plmkstrm(arg1);
9209 resultobj = SWIG_Py_Void();
9210 if (SWIG_IsTmpObj(res1)) {
9211 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
9212 } else {
9213 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9214 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
9215 }
9216 return resultobj;
9217fail:
9218 return NULL;
9219}
9220
9221
9222SWIGINTERN PyObject *_wrap_plmtex(PyObject *self, PyObject *args) {
9223 PyObject *resultobj = 0;
9224 char *arg1 = (char *) 0 ;
9225 PLFLT arg2 ;
9226 PLFLT arg3 ;
9227 PLFLT arg4 ;
9228 char *arg5 = (char *) 0 ;
9229 int res1 ;
9230 char *buf1 = 0 ;
9231 int alloc1 = 0 ;
9232 double val2 ;
9233 int ecode2 = 0 ;
9234 double val3 ;
9235 int ecode3 = 0 ;
9236 double val4 ;
9237 int ecode4 = 0 ;
9238 int res5 ;
9239 char *buf5 = 0 ;
9240 int alloc5 = 0 ;
9241 PyObject *swig_obj[5] ;
9242
9243 (void)self;
9244 if (!SWIG_Python_UnpackTuple(args, "plmtex", 5, 5, swig_obj)) SWIG_fail;
9245 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9246 if (!SWIG_IsOK(res1)) {
9247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
9248 }
9249 arg1 = (char *)(buf1);
9250 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9251 if (!SWIG_IsOK(ecode2)) {
9252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9253 }
9254 arg2 = (PLFLT)(val2);
9255 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9256 if (!SWIG_IsOK(ecode3)) {
9257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9258 }
9259 arg3 = (PLFLT)(val3);
9260 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9261 if (!SWIG_IsOK(ecode4)) {
9262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9263 }
9264 arg4 = (PLFLT)(val4);
9265 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9266 if (!SWIG_IsOK(res5)) {
9267 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9268 }
9269 arg5 = (char *)(buf5);
9270 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9271 resultobj = SWIG_Py_Void();
9272 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9273 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9274 return resultobj;
9275fail:
9276 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9277 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9278 return NULL;
9279}
9280
9281
9282SWIGINTERN PyObject *_wrap_plmtex3(PyObject *self, PyObject *args) {
9283 PyObject *resultobj = 0;
9284 char *arg1 = (char *) 0 ;
9285 PLFLT arg2 ;
9286 PLFLT arg3 ;
9287 PLFLT arg4 ;
9288 char *arg5 = (char *) 0 ;
9289 int res1 ;
9290 char *buf1 = 0 ;
9291 int alloc1 = 0 ;
9292 double val2 ;
9293 int ecode2 = 0 ;
9294 double val3 ;
9295 int ecode3 = 0 ;
9296 double val4 ;
9297 int ecode4 = 0 ;
9298 int res5 ;
9299 char *buf5 = 0 ;
9300 int alloc5 = 0 ;
9301 PyObject *swig_obj[5] ;
9302
9303 (void)self;
9304 if (!SWIG_Python_UnpackTuple(args, "plmtex3", 5, 5, swig_obj)) SWIG_fail;
9305 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9306 if (!SWIG_IsOK(res1)) {
9307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9308 }
9309 arg1 = (char *)(buf1);
9310 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9311 if (!SWIG_IsOK(ecode2)) {
9312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9313 }
9314 arg2 = (PLFLT)(val2);
9315 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9316 if (!SWIG_IsOK(ecode3)) {
9317 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9318 }
9319 arg3 = (PLFLT)(val3);
9320 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9321 if (!SWIG_IsOK(ecode4)) {
9322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9323 }
9324 arg4 = (PLFLT)(val4);
9325 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9326 if (!SWIG_IsOK(res5)) {
9327 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9328 }
9329 arg5 = (char *)(buf5);
9330 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9331 resultobj = SWIG_Py_Void();
9332 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9333 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9334 return resultobj;
9335fail:
9336 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9337 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9338 return NULL;
9339}
9340
9341
9342SWIGINTERN PyObject *_wrap_plot3d(PyObject *self, PyObject *args) {
9343 PyObject *resultobj = 0;
9344 PLFLT *arg1 = (PLFLT *) 0 ;
9345 PLFLT *arg2 = (PLFLT *) 0 ;
9346 PLFLT **arg3 = (PLFLT **) 0 ;
9347 PLINT arg4 ;
9348 PLINT arg5 ;
9349 PLINT arg6 ;
9350 PLBOOL arg7 ;
9351 PyArrayObject *tmp1 = NULL ;
9352 PyArrayObject *tmp2 = NULL ;
9353 PyArrayObject *tmp3 = NULL ;
9354 int val6 ;
9355 int ecode6 = 0 ;
9356 int val7 ;
9357 int ecode7 = 0 ;
9358 PyObject *swig_obj[5] ;
9359
9360 (void)self;
9361 if (!SWIG_Python_UnpackTuple(args, "plot3d", 5, 5, swig_obj)) SWIG_fail;
9362 {
9363 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9364 if ( tmp1 == NULL )
9365 return NULL;
9366 Xlen = PyArray_DIMS( tmp1 )[0];
9367 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9368 }
9369 {
9370 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9371 if ( tmp2 == NULL )
9372 return NULL;
9373 Ylen = PyArray_DIMS( tmp2 )[0];
9374 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9375 }
9376 {
9377 int i, size;
9378 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9379 if ( tmp3 == NULL )
9380 return NULL;
9381 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9382 {
9383 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9384 return NULL;
9385 }
9386 arg4 = PyArray_DIMS( tmp3 )[0];
9387 arg5 = PyArray_DIMS( tmp3 )[1];
9388 size = arg5;
9389 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9390 for ( i = 0; i < arg4; i++ )
9391 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9392 }
9393 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9394 if (!SWIG_IsOK(ecode6)) {
9395 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9396 }
9397 arg6 = (PLINT)(val6);
9398 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
9399 if (!SWIG_IsOK(ecode7)) {
9400 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9401 }
9402 arg7 = (PLBOOL)(val7);
9403 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9404 resultobj = SWIG_Py_Void();
9405 {
9406 Py_CLEAR( tmp1 );
9407 }
9408 {
9409 Py_CLEAR( tmp2 );
9410 }
9411 {
9412 Py_CLEAR( tmp3 );
9413 free( arg3 );
9414 }
9415 return resultobj;
9416fail:
9417 {
9418 Py_CLEAR( tmp1 );
9419 }
9420 {
9421 Py_CLEAR( tmp2 );
9422 }
9423 {
9424 Py_CLEAR( tmp3 );
9425 free( arg3 );
9426 }
9427 return NULL;
9428}
9429
9430
9431SWIGINTERN PyObject *_wrap_plot3dc(PyObject *self, PyObject *args) {
9432 PyObject *resultobj = 0;
9433 PLFLT *arg1 = (PLFLT *) 0 ;
9434 PLFLT *arg2 = (PLFLT *) 0 ;
9435 PLFLT **arg3 = (PLFLT **) 0 ;
9436 PLINT arg4 ;
9437 PLINT arg5 ;
9438 PLINT arg6 ;
9439 PLFLT *arg7 = (PLFLT *) 0 ;
9440 PLINT arg8 ;
9441 PyArrayObject *tmp1 = NULL ;
9442 PyArrayObject *tmp2 = NULL ;
9443 PyArrayObject *tmp3 = NULL ;
9444 int val6 ;
9445 int ecode6 = 0 ;
9446 PyArrayObject *tmp7 = NULL ;
9447 PyObject *swig_obj[5] ;
9448
9449 (void)self;
9450 if (!SWIG_Python_UnpackTuple(args, "plot3dc", 5, 5, swig_obj)) SWIG_fail;
9451 {
9452 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9453 if ( tmp1 == NULL )
9454 return NULL;
9455 Xlen = PyArray_DIMS( tmp1 )[0];
9456 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9457 }
9458 {
9459 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9460 if ( tmp2 == NULL )
9461 return NULL;
9462 Ylen = PyArray_DIMS( tmp2 )[0];
9463 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9464 }
9465 {
9466 int i, size;
9467 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9468 if ( tmp3 == NULL )
9469 return NULL;
9470 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9471 {
9472 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9473 return NULL;
9474 }
9475 arg4 = PyArray_DIMS( tmp3 )[0];
9476 arg5 = PyArray_DIMS( tmp3 )[1];
9477 size = arg5;
9478 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9479 for ( i = 0; i < arg4; i++ )
9480 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9481 }
9482 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9483 if (!SWIG_IsOK(ecode6)) {
9484 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9485 }
9486 arg6 = (PLINT)(val6);
9487 {
9488 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9489 if ( tmp7 == NULL )
9490 return NULL;
9491 arg8 = PyArray_DIMS( tmp7 )[0];
9492 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9493 }
9494 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9495 resultobj = SWIG_Py_Void();
9496 {
9497 Py_CLEAR( tmp1 );
9498 }
9499 {
9500 Py_CLEAR( tmp2 );
9501 }
9502 {
9503 Py_CLEAR( tmp3 );
9504 free( arg3 );
9505 }
9506 {
9507 Py_CLEAR( tmp7 );
9508 }
9509 return resultobj;
9510fail:
9511 {
9512 Py_CLEAR( tmp1 );
9513 }
9514 {
9515 Py_CLEAR( tmp2 );
9516 }
9517 {
9518 Py_CLEAR( tmp3 );
9519 free( arg3 );
9520 }
9521 {
9522 Py_CLEAR( tmp7 );
9523 }
9524 return NULL;
9525}
9526
9527
9528SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *self, PyObject *args) {
9529 PyObject *resultobj = 0;
9530 PLFLT *arg1 = (PLFLT *) 0 ;
9531 PLFLT *arg2 = (PLFLT *) 0 ;
9532 PLFLT **arg3 = (PLFLT **) 0 ;
9533 PLINT arg4 ;
9534 PLINT arg5 ;
9535 PLINT arg6 ;
9536 PLFLT *arg7 = (PLFLT *) 0 ;
9537 PLINT arg8 ;
9538 PLINT arg9 ;
9539 PLINT arg10 ;
9540 PLINT *arg11 = (PLINT *) 0 ;
9541 PLINT *arg12 = (PLINT *) 0 ;
9542 PyArrayObject *tmp1 = NULL ;
9543 PyArrayObject *tmp2 = NULL ;
9544 PyArrayObject *tmp3 = NULL ;
9545 int val6 ;
9546 int ecode6 = 0 ;
9547 PyArrayObject *tmp7 = NULL ;
9548 int val9 ;
9549 int ecode9 = 0 ;
9550 PyArrayObject *tmp10 = NULL ;
9551 PyArrayObject *tmp12 = NULL ;
9552 PyObject *swig_obj[8] ;
9553
9554 (void)self;
9555 if (!SWIG_Python_UnpackTuple(args, "plot3dcl", 8, 8, swig_obj)) SWIG_fail;
9556 {
9557 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9558 if ( tmp1 == NULL )
9559 return NULL;
9560 Xlen = PyArray_DIMS( tmp1 )[0];
9561 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9562 }
9563 {
9564 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9565 if ( tmp2 == NULL )
9566 return NULL;
9567 Ylen = PyArray_DIMS( tmp2 )[0];
9568 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9569 }
9570 {
9571 int i, size;
9572 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9573 if ( tmp3 == NULL )
9574 return NULL;
9575 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9576 {
9577 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9578 return NULL;
9579 }
9580 arg4 = PyArray_DIMS( tmp3 )[0];
9581 arg5 = PyArray_DIMS( tmp3 )[1];
9582 size = arg5;
9583 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9584 for ( i = 0; i < arg4; i++ )
9585 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9586 }
9587 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9588 if (!SWIG_IsOK(ecode6)) {
9589 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9590 }
9591 arg6 = (PLINT)(val6);
9592 {
9593 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9594 if ( tmp7 == NULL )
9595 return NULL;
9596 arg8 = PyArray_DIMS( tmp7 )[0];
9597 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9598 }
9599 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9600 if (!SWIG_IsOK(ecode9)) {
9601 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9602 }
9603 arg9 = (PLINT)(val9);
9604 {
9605 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9606 if ( tmp10 == NULL )
9607 return NULL;
9608 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9609 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9610 }
9611 {
9612 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9613 if ( tmp12 == NULL )
9614 return NULL;
9615 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9616 {
9617 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9618 return NULL;
9619 }
9620 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9621 }
9622 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);
9623 resultobj = SWIG_Py_Void();
9624 {
9625 Py_CLEAR( tmp1 );
9626 }
9627 {
9628 Py_CLEAR( tmp2 );
9629 }
9630 {
9631 Py_CLEAR( tmp3 );
9632 free( arg3 );
9633 }
9634 {
9635 Py_CLEAR( tmp7 );
9636 }
9637 {
9638 Py_CLEAR( tmp10 );
9639 }
9640 {
9641 Py_CLEAR( tmp12 );
9642 }
9643 return resultobj;
9644fail:
9645 {
9646 Py_CLEAR( tmp1 );
9647 }
9648 {
9649 Py_CLEAR( tmp2 );
9650 }
9651 {
9652 Py_CLEAR( tmp3 );
9653 free( arg3 );
9654 }
9655 {
9656 Py_CLEAR( tmp7 );
9657 }
9658 {
9659 Py_CLEAR( tmp10 );
9660 }
9661 {
9662 Py_CLEAR( tmp12 );
9663 }
9664 return NULL;
9665}
9666
9667
9668SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *self, PyObject *args) {
9669 PyObject *resultobj = 0;
9670 PLFLT *arg1 = (PLFLT *) 0 ;
9671 PLFLT *arg2 = (PLFLT *) 0 ;
9672 PLFLT **arg3 = (PLFLT **) 0 ;
9673 PLINT arg4 ;
9674 PLINT arg5 ;
9675 PLINT arg6 ;
9676 PLFLT *arg7 = (PLFLT *) 0 ;
9677 PLINT arg8 ;
9678 PyArrayObject *tmp1 = NULL ;
9679 PyArrayObject *tmp2 = NULL ;
9680 PyArrayObject *tmp3 = NULL ;
9681 int val6 ;
9682 int ecode6 = 0 ;
9683 PyArrayObject *tmp7 = NULL ;
9684 PyObject *swig_obj[5] ;
9685
9686 (void)self;
9687 if (!SWIG_Python_UnpackTuple(args, "plsurf3d", 5, 5, swig_obj)) SWIG_fail;
9688 {
9689 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9690 if ( tmp1 == NULL )
9691 return NULL;
9692 Xlen = PyArray_DIMS( tmp1 )[0];
9693 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9694 }
9695 {
9696 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9697 if ( tmp2 == NULL )
9698 return NULL;
9699 Ylen = PyArray_DIMS( tmp2 )[0];
9700 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9701 }
9702 {
9703 int i, size;
9704 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9705 if ( tmp3 == NULL )
9706 return NULL;
9707 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9708 {
9709 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9710 return NULL;
9711 }
9712 arg4 = PyArray_DIMS( tmp3 )[0];
9713 arg5 = PyArray_DIMS( tmp3 )[1];
9714 size = arg5;
9715 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9716 for ( i = 0; i < arg4; i++ )
9717 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9718 }
9719 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9720 if (!SWIG_IsOK(ecode6)) {
9721 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9722 }
9723 arg6 = (PLINT)(val6);
9724 {
9725 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9726 if ( tmp7 == NULL )
9727 return NULL;
9728 arg8 = PyArray_DIMS( tmp7 )[0];
9729 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9730 }
9731 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9732 resultobj = SWIG_Py_Void();
9733 {
9734 Py_CLEAR( tmp1 );
9735 }
9736 {
9737 Py_CLEAR( tmp2 );
9738 }
9739 {
9740 Py_CLEAR( tmp3 );
9741 free( arg3 );
9742 }
9743 {
9744 Py_CLEAR( tmp7 );
9745 }
9746 return resultobj;
9747fail:
9748 {
9749 Py_CLEAR( tmp1 );
9750 }
9751 {
9752 Py_CLEAR( tmp2 );
9753 }
9754 {
9755 Py_CLEAR( tmp3 );
9756 free( arg3 );
9757 }
9758 {
9759 Py_CLEAR( tmp7 );
9760 }
9761 return NULL;
9762}
9763
9764
9765SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *self, PyObject *args) {
9766 PyObject *resultobj = 0;
9767 PLFLT *arg1 = (PLFLT *) 0 ;
9768 PLFLT *arg2 = (PLFLT *) 0 ;
9769 PLFLT **arg3 = (PLFLT **) 0 ;
9770 PLINT arg4 ;
9771 PLINT arg5 ;
9772 PLINT arg6 ;
9773 PLFLT *arg7 = (PLFLT *) 0 ;
9774 PLINT arg8 ;
9775 PLINT arg9 ;
9776 PLINT arg10 ;
9777 PLINT *arg11 = (PLINT *) 0 ;
9778 PLINT *arg12 = (PLINT *) 0 ;
9779 PyArrayObject *tmp1 = NULL ;
9780 PyArrayObject *tmp2 = NULL ;
9781 PyArrayObject *tmp3 = NULL ;
9782 int val6 ;
9783 int ecode6 = 0 ;
9784 PyArrayObject *tmp7 = NULL ;
9785 int val9 ;
9786 int ecode9 = 0 ;
9787 PyArrayObject *tmp10 = NULL ;
9788 PyArrayObject *tmp12 = NULL ;
9789 PyObject *swig_obj[8] ;
9790
9791 (void)self;
9792 if (!SWIG_Python_UnpackTuple(args, "plsurf3dl", 8, 8, swig_obj)) SWIG_fail;
9793 {
9794 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9795 if ( tmp1 == NULL )
9796 return NULL;
9797 Xlen = PyArray_DIMS( tmp1 )[0];
9798 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9799 }
9800 {
9801 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9802 if ( tmp2 == NULL )
9803 return NULL;
9804 Ylen = PyArray_DIMS( tmp2 )[0];
9805 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9806 }
9807 {
9808 int i, size;
9809 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9810 if ( tmp3 == NULL )
9811 return NULL;
9812 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9813 {
9814 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9815 return NULL;
9816 }
9817 arg4 = PyArray_DIMS( tmp3 )[0];
9818 arg5 = PyArray_DIMS( tmp3 )[1];
9819 size = arg5;
9820 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9821 for ( i = 0; i < arg4; i++ )
9822 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9823 }
9824 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9825 if (!SWIG_IsOK(ecode6)) {
9826 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9827 }
9828 arg6 = (PLINT)(val6);
9829 {
9830 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9831 if ( tmp7 == NULL )
9832 return NULL;
9833 arg8 = PyArray_DIMS( tmp7 )[0];
9834 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9835 }
9836 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9837 if (!SWIG_IsOK(ecode9)) {
9838 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9839 }
9840 arg9 = (PLINT)(val9);
9841 {
9842 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9843 if ( tmp10 == NULL )
9844 return NULL;
9845 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9846 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9847 }
9848 {
9849 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9850 if ( tmp12 == NULL )
9851 return NULL;
9852 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9853 {
9854 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9855 return NULL;
9856 }
9857 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9858 }
9859 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);
9860 resultobj = SWIG_Py_Void();
9861 {
9862 Py_CLEAR( tmp1 );
9863 }
9864 {
9865 Py_CLEAR( tmp2 );
9866 }
9867 {
9868 Py_CLEAR( tmp3 );
9869 free( arg3 );
9870 }
9871 {
9872 Py_CLEAR( tmp7 );
9873 }
9874 {
9875 Py_CLEAR( tmp10 );
9876 }
9877 {
9878 Py_CLEAR( tmp12 );
9879 }
9880 return resultobj;
9881fail:
9882 {
9883 Py_CLEAR( tmp1 );
9884 }
9885 {
9886 Py_CLEAR( tmp2 );
9887 }
9888 {
9889 Py_CLEAR( tmp3 );
9890 free( arg3 );
9891 }
9892 {
9893 Py_CLEAR( tmp7 );
9894 }
9895 {
9896 Py_CLEAR( tmp10 );
9897 }
9898 {
9899 Py_CLEAR( tmp12 );
9900 }
9901 return NULL;
9902}
9903
9904
9905SWIGINTERN PyObject *_wrap_plparseopts(PyObject *self, PyObject *args) {
9906 PyObject *resultobj = 0;
9907 int *arg1 = (int *) 0 ;
9908 char **arg2 = (char **) 0 ;
9909 PLINT arg3 ;
9910 int tmp1 ;
9911 int val3 ;
9912 int ecode3 = 0 ;
9913 PyObject *swig_obj[2] ;
9914 PLINT result;
9915
9916 (void)self;
9917 if (!SWIG_Python_UnpackTuple(args, "plparseopts", 2, 2, swig_obj)) SWIG_fail;
9918 {
9919 int i;
9920 PyObject *unicode_string;
9921
9922 if ( !PyList_Check( swig_obj[0] ) )
9923 {
9924 PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9925 return NULL;
9926 }
9927 tmp1 = PyList_Size( swig_obj[0] );
9928 arg1 = &tmp1;
9929 arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9930 for ( i = 0; i < tmp1; i++ )
9931 {
9932 PyObject *s = PyList_GetItem( swig_obj[0], i );
9933 if ( PyString_Check( s ) )
9934 {
9935 arg2[i] = PyString_AsString( s );
9936 }
9937 else if ( PyUnicode_Check( s ) )
9938 {
9939 // unicode_string is never freed? memory leak here?
9940 unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9941 arg2[i] = PyBytes_AS_STRING( unicode_string );
9942 }
9943 else
9944 {
9945 free( arg2 );
9946 PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9947 return NULL;
9948 }
9949 }
9950 arg2[i] = 0;
9951 }
9952 ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
9953 if (!SWIG_IsOK(ecode3)) {
9954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9955 }
9956 arg3 = (PLINT)(val3);
9957 result = (PLINT)plparseopts(arg1,arg2,arg3);
9958 resultobj = SWIG_From_int((int)(result));
9959 {
9960 if ( arg2 )
9961 free( arg2 );
9962 }
9963 return resultobj;
9964fail:
9965 {
9966 if ( arg2 )
9967 free( arg2 );
9968 }
9969 return NULL;
9970}
9971
9972
9973SWIGINTERN PyObject *_wrap_plpat(PyObject *self, PyObject *args) {
9974 PyObject *resultobj = 0;
9975 PLINT arg1 ;
9976 PLINT *arg2 = (PLINT *) 0 ;
9977 PLINT *arg3 = (PLINT *) 0 ;
9978 PyArrayObject *tmp1 = NULL ;
9979 PyArrayObject *tmp3 = NULL ;
9980 PyObject *swig_obj[2] ;
9981
9982 (void)self;
9983 if (!SWIG_Python_UnpackTuple(args, "plpat", 2, 2, swig_obj)) SWIG_fail;
9984 {
9985 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
9986 if ( tmp1 == NULL )
9987 return NULL;
9988 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9989 arg2 = (PLINT *) PyArray_DATA( tmp1 );
9990 }
9991 {
9992 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
9993 if ( tmp3 == NULL )
9994 return NULL;
9995 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9996 {
9997 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9998 return NULL;
9999 }
10000 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10001 }
10002 plpat(arg1,(int const *)arg2,(int const *)arg3);
10003 resultobj = SWIG_Py_Void();
10004 {
10005 Py_CLEAR( tmp1 );
10006 }
10007 {
10008 Py_CLEAR( tmp3 );
10009 }
10010 return resultobj;
10011fail:
10012 {
10013 Py_CLEAR( tmp1 );
10014 }
10015 {
10016 Py_CLEAR( tmp3 );
10017 }
10018 return NULL;
10019}
10020
10021
10022SWIGINTERN PyObject *_wrap_plpath(PyObject *self, PyObject *args) {
10023 PyObject *resultobj = 0;
10024 PLINT arg1 ;
10025 PLFLT arg2 ;
10026 PLFLT arg3 ;
10027 PLFLT arg4 ;
10028 PLFLT arg5 ;
10029 int val1 ;
10030 int ecode1 = 0 ;
10031 double val2 ;
10032 int ecode2 = 0 ;
10033 double val3 ;
10034 int ecode3 = 0 ;
10035 double val4 ;
10036 int ecode4 = 0 ;
10037 double val5 ;
10038 int ecode5 = 0 ;
10039 PyObject *swig_obj[5] ;
10040
10041 (void)self;
10042 if (!SWIG_Python_UnpackTuple(args, "plpath", 5, 5, swig_obj)) SWIG_fail;
10043 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10044 if (!SWIG_IsOK(ecode1)) {
10045 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
10046 }
10047 arg1 = (PLINT)(val1);
10048 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10049 if (!SWIG_IsOK(ecode2)) {
10050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
10051 }
10052 arg2 = (PLFLT)(val2);
10053 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10054 if (!SWIG_IsOK(ecode3)) {
10055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
10056 }
10057 arg3 = (PLFLT)(val3);
10058 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10059 if (!SWIG_IsOK(ecode4)) {
10060 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
10061 }
10062 arg4 = (PLFLT)(val4);
10063 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10064 if (!SWIG_IsOK(ecode5)) {
10065 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
10066 }
10067 arg5 = (PLFLT)(val5);
10068 plpath(arg1,arg2,arg3,arg4,arg5);
10069 resultobj = SWIG_Py_Void();
10070 return resultobj;
10071fail:
10072 return NULL;
10073}
10074
10075
10076SWIGINTERN PyObject *_wrap_plpoin(PyObject *self, PyObject *args) {
10077 PyObject *resultobj = 0;
10078 PLINT arg1 ;
10079 PLFLT *arg2 = (PLFLT *) 0 ;
10080 PLFLT *arg3 = (PLFLT *) 0 ;
10081 PLINT arg4 ;
10082 PyArrayObject *tmp1 = NULL ;
10083 PyArrayObject *tmp3 = NULL ;
10084 int val4 ;
10085 int ecode4 = 0 ;
10086 PyObject *swig_obj[3] ;
10087
10088 (void)self;
10089 if (!SWIG_Python_UnpackTuple(args, "plpoin", 3, 3, swig_obj)) SWIG_fail;
10090 {
10091 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10092 if ( tmp1 == NULL )
10093 return NULL;
10094 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10095 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10096 }
10097 {
10098 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10099 if ( tmp3 == NULL )
10100 return NULL;
10101 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10102 {
10103 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10104 return NULL;
10105 }
10106 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10107 }
10108 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
10109 if (!SWIG_IsOK(ecode4)) {
10110 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
10111 }
10112 arg4 = (PLINT)(val4);
10113 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
10114 resultobj = SWIG_Py_Void();
10115 {
10116 Py_CLEAR( tmp1 );
10117 }
10118 {
10119 Py_CLEAR( tmp3 );
10120 }
10121 return resultobj;
10122fail:
10123 {
10124 Py_CLEAR( tmp1 );
10125 }
10126 {
10127 Py_CLEAR( tmp3 );
10128 }
10129 return NULL;
10130}
10131
10132
10133SWIGINTERN PyObject *_wrap_plpoin3(PyObject *self, PyObject *args) {
10134 PyObject *resultobj = 0;
10135 PLINT arg1 ;
10136 PLFLT *arg2 = (PLFLT *) 0 ;
10137 PLFLT *arg3 = (PLFLT *) 0 ;
10138 PLFLT *arg4 = (PLFLT *) 0 ;
10139 PLINT arg5 ;
10140 PyArrayObject *tmp1 = NULL ;
10141 PyArrayObject *tmp3 = NULL ;
10142 PyArrayObject *tmp4 = NULL ;
10143 int val5 ;
10144 int ecode5 = 0 ;
10145 PyObject *swig_obj[4] ;
10146
10147 (void)self;
10148 if (!SWIG_Python_UnpackTuple(args, "plpoin3", 4, 4, swig_obj)) SWIG_fail;
10149 {
10150 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10151 if ( tmp1 == NULL )
10152 return NULL;
10153 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10154 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10155 }
10156 {
10157 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10158 if ( tmp3 == NULL )
10159 return NULL;
10160 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10161 {
10162 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10163 return NULL;
10164 }
10165 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10166 }
10167 {
10168 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10169 if ( tmp4 == NULL )
10170 return NULL;
10171 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10172 {
10173 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10174 return NULL;
10175 }
10176 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10177 }
10178 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
10179 if (!SWIG_IsOK(ecode5)) {
10180 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
10181 }
10182 arg5 = (PLINT)(val5);
10183 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
10184 resultobj = SWIG_Py_Void();
10185 {
10186 Py_CLEAR( tmp1 );
10187 }
10188 {
10189 Py_CLEAR( tmp3 );
10190 }
10191 {
10192 Py_CLEAR( tmp4 );
10193 }
10194 return resultobj;
10195fail:
10196 {
10197 Py_CLEAR( tmp1 );
10198 }
10199 {
10200 Py_CLEAR( tmp3 );
10201 }
10202 {
10203 Py_CLEAR( tmp4 );
10204 }
10205 return NULL;
10206}
10207
10208
10209SWIGINTERN PyObject *_wrap_plpoly3(PyObject *self, PyObject *args) {
10210 PyObject *resultobj = 0;
10211 PLINT arg1 ;
10212 PLFLT *arg2 = (PLFLT *) 0 ;
10213 PLFLT *arg3 = (PLFLT *) 0 ;
10214 PLFLT *arg4 = (PLFLT *) 0 ;
10215 PLBOOL *arg5 = (PLBOOL *) 0 ;
10216 PLBOOL arg6 ;
10217 PyArrayObject *tmp1 = NULL ;
10218 PyArrayObject *tmp3 = NULL ;
10219 PyArrayObject *tmp4 = NULL ;
10220 PyArrayObject *tmp5 = NULL ;
10221 int val6 ;
10222 int ecode6 = 0 ;
10223 PyObject *swig_obj[5] ;
10224
10225 (void)self;
10226 if (!SWIG_Python_UnpackTuple(args, "plpoly3", 5, 5, swig_obj)) SWIG_fail;
10227 {
10228 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10229 if ( tmp1 == NULL )
10230 return NULL;
10231 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10232 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10233 }
10234 {
10235 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10236 if ( tmp3 == NULL )
10237 return NULL;
10238 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10239 {
10240 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10241 return NULL;
10242 }
10243 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10244 }
10245 {
10246 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10247 if ( tmp4 == NULL )
10248 return NULL;
10249 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10250 {
10251 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10252 return NULL;
10253 }
10254 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10255 }
10256 {
10257 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[3], NPY_PLINT, 1, 1 );
10258 if ( tmp5 == NULL )
10259 return NULL;
10260 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10261 {
10262 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10263 return NULL;
10264 }
10265 arg5 = (PLINT *) PyArray_DATA( tmp5 );
10266 }
10267 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
10268 if (!SWIG_IsOK(ecode6)) {
10269 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10270 }
10271 arg6 = (PLBOOL)(val6);
10272 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10273 resultobj = SWIG_Py_Void();
10274 {
10275 Py_CLEAR( tmp1 );
10276 }
10277 {
10278 Py_CLEAR( tmp3 );
10279 }
10280 {
10281 Py_CLEAR( tmp4 );
10282 }
10283 {
10284 Py_CLEAR( tmp5 );
10285 }
10286 return resultobj;
10287fail:
10288 {
10289 Py_CLEAR( tmp1 );
10290 }
10291 {
10292 Py_CLEAR( tmp3 );
10293 }
10294 {
10295 Py_CLEAR( tmp4 );
10296 }
10297 {
10298 Py_CLEAR( tmp5 );
10299 }
10300 return NULL;
10301}
10302
10303
10304SWIGINTERN PyObject *_wrap_plprec(PyObject *self, PyObject *args) {
10305 PyObject *resultobj = 0;
10306 PLINT arg1 ;
10307 PLINT arg2 ;
10308 int val1 ;
10309 int ecode1 = 0 ;
10310 int val2 ;
10311 int ecode2 = 0 ;
10312 PyObject *swig_obj[2] ;
10313
10314 (void)self;
10315 if (!SWIG_Python_UnpackTuple(args, "plprec", 2, 2, swig_obj)) SWIG_fail;
10316 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10317 if (!SWIG_IsOK(ecode1)) {
10318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10319 }
10320 arg1 = (PLINT)(val1);
10321 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10322 if (!SWIG_IsOK(ecode2)) {
10323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10324 }
10325 arg2 = (PLINT)(val2);
10326 plprec(arg1,arg2);
10327 resultobj = SWIG_Py_Void();
10328 return resultobj;
10329fail:
10330 return NULL;
10331}
10332
10333
10334SWIGINTERN PyObject *_wrap_plpsty(PyObject *self, PyObject *args) {
10335 PyObject *resultobj = 0;
10336 PLINT arg1 ;
10337 int val1 ;
10338 int ecode1 = 0 ;
10339 PyObject *swig_obj[1] ;
10340
10341 (void)self;
10342 if (!args) SWIG_fail;
10343 swig_obj[0] = args;
10344 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10345 if (!SWIG_IsOK(ecode1)) {
10346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10347 }
10348 arg1 = (PLINT)(val1);
10349 plpsty(arg1);
10350 resultobj = SWIG_Py_Void();
10351 return resultobj;
10352fail:
10353 return NULL;
10354}
10355
10356
10357SWIGINTERN PyObject *_wrap_plptex(PyObject *self, PyObject *args) {
10358 PyObject *resultobj = 0;
10359 PLFLT arg1 ;
10360 PLFLT arg2 ;
10361 PLFLT arg3 ;
10362 PLFLT arg4 ;
10363 PLFLT arg5 ;
10364 char *arg6 = (char *) 0 ;
10365 double val1 ;
10366 int ecode1 = 0 ;
10367 double val2 ;
10368 int ecode2 = 0 ;
10369 double val3 ;
10370 int ecode3 = 0 ;
10371 double val4 ;
10372 int ecode4 = 0 ;
10373 double val5 ;
10374 int ecode5 = 0 ;
10375 int res6 ;
10376 char *buf6 = 0 ;
10377 int alloc6 = 0 ;
10378 PyObject *swig_obj[6] ;
10379
10380 (void)self;
10381 if (!SWIG_Python_UnpackTuple(args, "plptex", 6, 6, swig_obj)) SWIG_fail;
10382 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10383 if (!SWIG_IsOK(ecode1)) {
10384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10385 }
10386 arg1 = (PLFLT)(val1);
10387 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10388 if (!SWIG_IsOK(ecode2)) {
10389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10390 }
10391 arg2 = (PLFLT)(val2);
10392 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10393 if (!SWIG_IsOK(ecode3)) {
10394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10395 }
10396 arg3 = (PLFLT)(val3);
10397 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10398 if (!SWIG_IsOK(ecode4)) {
10399 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10400 }
10401 arg4 = (PLFLT)(val4);
10402 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10403 if (!SWIG_IsOK(ecode5)) {
10404 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10405 }
10406 arg5 = (PLFLT)(val5);
10407 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
10408 if (!SWIG_IsOK(res6)) {
10409 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10410 }
10411 arg6 = (char *)(buf6);
10412 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10413 resultobj = SWIG_Py_Void();
10414 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10415 return resultobj;
10416fail:
10417 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10418 return NULL;
10419}
10420
10421
10422SWIGINTERN PyObject *_wrap_plptex3(PyObject *self, PyObject *args) {
10423 PyObject *resultobj = 0;
10424 PLFLT arg1 ;
10425 PLFLT arg2 ;
10426 PLFLT arg3 ;
10427 PLFLT arg4 ;
10428 PLFLT arg5 ;
10429 PLFLT arg6 ;
10430 PLFLT arg7 ;
10431 PLFLT arg8 ;
10432 PLFLT arg9 ;
10433 PLFLT arg10 ;
10434 char *arg11 = (char *) 0 ;
10435 double val1 ;
10436 int ecode1 = 0 ;
10437 double val2 ;
10438 int ecode2 = 0 ;
10439 double val3 ;
10440 int ecode3 = 0 ;
10441 double val4 ;
10442 int ecode4 = 0 ;
10443 double val5 ;
10444 int ecode5 = 0 ;
10445 double val6 ;
10446 int ecode6 = 0 ;
10447 double val7 ;
10448 int ecode7 = 0 ;
10449 double val8 ;
10450 int ecode8 = 0 ;
10451 double val9 ;
10452 int ecode9 = 0 ;
10453 double val10 ;
10454 int ecode10 = 0 ;
10455 int res11 ;
10456 char *buf11 = 0 ;
10457 int alloc11 = 0 ;
10458 PyObject *swig_obj[11] ;
10459
10460 (void)self;
10461 if (!SWIG_Python_UnpackTuple(args, "plptex3", 11, 11, swig_obj)) SWIG_fail;
10462 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10463 if (!SWIG_IsOK(ecode1)) {
10464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10465 }
10466 arg1 = (PLFLT)(val1);
10467 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10468 if (!SWIG_IsOK(ecode2)) {
10469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10470 }
10471 arg2 = (PLFLT)(val2);
10472 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10473 if (!SWIG_IsOK(ecode3)) {
10474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10475 }
10476 arg3 = (PLFLT)(val3);
10477 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10478 if (!SWIG_IsOK(ecode4)) {
10479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10480 }
10481 arg4 = (PLFLT)(val4);
10482 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10483 if (!SWIG_IsOK(ecode5)) {
10484 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10485 }
10486 arg5 = (PLFLT)(val5);
10487 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
10488 if (!SWIG_IsOK(ecode6)) {
10489 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10490 }
10491 arg6 = (PLFLT)(val6);
10492 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
10493 if (!SWIG_IsOK(ecode7)) {
10494 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10495 }
10496 arg7 = (PLFLT)(val7);
10497 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
10498 if (!SWIG_IsOK(ecode8)) {
10499 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10500 }
10501 arg8 = (PLFLT)(val8);
10502 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
10503 if (!SWIG_IsOK(ecode9)) {
10504 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10505 }
10506 arg9 = (PLFLT)(val9);
10507 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
10508 if (!SWIG_IsOK(ecode10)) {
10509 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10510 }
10511 arg10 = (PLFLT)(val10);
10512 res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
10513 if (!SWIG_IsOK(res11)) {
10514 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10515 }
10516 arg11 = (char *)(buf11);
10517 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10518 resultobj = SWIG_Py_Void();
10519 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10520 return resultobj;
10521fail:
10522 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10523 return NULL;
10524}
10525
10526
10527SWIGINTERN PyObject *_wrap_plrandd(PyObject *self, PyObject *args) {
10528 PyObject *resultobj = 0;
10529 PLFLT result;
10530
10531 (void)self;
10532 if (!SWIG_Python_UnpackTuple(args, "plrandd", 0, 0, 0)) SWIG_fail;
10533 result = (PLFLT)plrandd();
10534 resultobj = SWIG_From_double((double)(result));
10535 return resultobj;
10536fail:
10537 return NULL;
10538}
10539
10540
10541SWIGINTERN PyObject *_wrap_plreplot(PyObject *self, PyObject *args) {
10542 PyObject *resultobj = 0;
10543
10544 (void)self;
10545 if (!SWIG_Python_UnpackTuple(args, "plreplot", 0, 0, 0)) SWIG_fail;
10546 plreplot();
10547 resultobj = SWIG_Py_Void();
10548 return resultobj;
10549fail:
10550 return NULL;
10551}
10552
10553
10554SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *self, PyObject *args) {
10555 PyObject *resultobj = 0;
10556 PLFLT arg1 ;
10557 PLFLT arg2 ;
10558 PLFLT arg3 ;
10559 PLFLT *arg4 = (PLFLT *) 0 ;
10560 PLFLT *arg5 = (PLFLT *) 0 ;
10561 PLFLT *arg6 = (PLFLT *) 0 ;
10562 double val1 ;
10563 int ecode1 = 0 ;
10564 double val2 ;
10565 int ecode2 = 0 ;
10566 double val3 ;
10567 int ecode3 = 0 ;
10568 PLFLT temp4 ;
10569 int res4 = SWIG_TMPOBJ ;
10570 PLFLT temp5 ;
10571 int res5 = SWIG_TMPOBJ ;
10572 PLFLT temp6 ;
10573 int res6 = SWIG_TMPOBJ ;
10574 PyObject *swig_obj[3] ;
10575
10576 arg4 = &temp4;
10577 arg5 = &temp5;
10578 arg6 = &temp6;
10579 (void)self;
10580 if (!SWIG_Python_UnpackTuple(args, "plrgbhls", 3, 3, swig_obj)) SWIG_fail;
10581 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10582 if (!SWIG_IsOK(ecode1)) {
10583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10584 }
10585 arg1 = (PLFLT)(val1);
10586 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10587 if (!SWIG_IsOK(ecode2)) {
10588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10589 }
10590 arg2 = (PLFLT)(val2);
10591 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10592 if (!SWIG_IsOK(ecode3)) {
10593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10594 }
10595 arg3 = (PLFLT)(val3);
10596 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10597 resultobj = SWIG_Py_Void();
10598 if (SWIG_IsTmpObj(res4)) {
10599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10600 } else {
10601 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10603 }
10604 if (SWIG_IsTmpObj(res5)) {
10605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10606 } else {
10607 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10608 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10609 }
10610 if (SWIG_IsTmpObj(res6)) {
10611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10612 } else {
10613 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10615 }
10616 return resultobj;
10617fail:
10618 return NULL;
10619}
10620
10621
10622SWIGINTERN PyObject *_wrap_plschr(PyObject *self, PyObject *args) {
10623 PyObject *resultobj = 0;
10624 PLFLT arg1 ;
10625 PLFLT arg2 ;
10626 double val1 ;
10627 int ecode1 = 0 ;
10628 double val2 ;
10629 int ecode2 = 0 ;
10630 PyObject *swig_obj[2] ;
10631
10632 (void)self;
10633 if (!SWIG_Python_UnpackTuple(args, "plschr", 2, 2, swig_obj)) SWIG_fail;
10634 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10635 if (!SWIG_IsOK(ecode1)) {
10636 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10637 }
10638 arg1 = (PLFLT)(val1);
10639 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10640 if (!SWIG_IsOK(ecode2)) {
10641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10642 }
10643 arg2 = (PLFLT)(val2);
10644 plschr(arg1,arg2);
10645 resultobj = SWIG_Py_Void();
10646 return resultobj;
10647fail:
10648 return NULL;
10649}
10650
10651
10652SWIGINTERN PyObject *_wrap_plscmap0(PyObject *self, PyObject *args) {
10653 PyObject *resultobj = 0;
10654 PLINT *arg1 = (PLINT *) 0 ;
10655 PLINT *arg2 = (PLINT *) 0 ;
10656 PLINT *arg3 = (PLINT *) 0 ;
10657 PLINT arg4 ;
10658 PyArrayObject *tmp1 = NULL ;
10659 PyArrayObject *tmp2 = NULL ;
10660 PyArrayObject *tmp3 = NULL ;
10661 PyObject *swig_obj[3] ;
10662
10663 (void)self;
10664 if (!SWIG_Python_UnpackTuple(args, "plscmap0", 3, 3, swig_obj)) SWIG_fail;
10665 {
10666 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10667 if ( tmp1 == NULL )
10668 return NULL;
10669 Alen = PyArray_DIMS( tmp1 )[0];
10670 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10671 }
10672 {
10673 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10674 if ( tmp2 == NULL )
10675 return NULL;
10676 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10677 {
10678 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10679 return NULL;
10680 }
10681 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10682 }
10683 {
10684 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10685 if ( tmp3 == NULL )
10686 return NULL;
10687 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10688 {
10689 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10690 return NULL;
10691 }
10692 arg4 = PyArray_DIMS( tmp3 )[0];
10693 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10694 }
10695 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10696 resultobj = SWIG_Py_Void();
10697 {
10698 Py_CLEAR( tmp1 );
10699 }
10700 {
10701 Py_CLEAR( tmp2 );
10702 }
10703 {
10704 Py_CLEAR( tmp3 );
10705 }
10706 return resultobj;
10707fail:
10708 {
10709 Py_CLEAR( tmp1 );
10710 }
10711 {
10712 Py_CLEAR( tmp2 );
10713 }
10714 {
10715 Py_CLEAR( tmp3 );
10716 }
10717 return NULL;
10718}
10719
10720
10721SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *self, PyObject *args) {
10722 PyObject *resultobj = 0;
10723 PLINT *arg1 = (PLINT *) 0 ;
10724 PLINT *arg2 = (PLINT *) 0 ;
10725 PLINT *arg3 = (PLINT *) 0 ;
10726 PLFLT *arg4 = (PLFLT *) 0 ;
10727 PLINT arg5 ;
10728 PyArrayObject *tmp1 = NULL ;
10729 PyArrayObject *tmp2 = NULL ;
10730 PyArrayObject *tmp3 = NULL ;
10731 PyArrayObject *tmp4 = NULL ;
10732 PyObject *swig_obj[4] ;
10733
10734 (void)self;
10735 if (!SWIG_Python_UnpackTuple(args, "plscmap0a", 4, 4, swig_obj)) SWIG_fail;
10736 {
10737 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10738 if ( tmp1 == NULL )
10739 return NULL;
10740 Alen = PyArray_DIMS( tmp1 )[0];
10741 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10742 }
10743 {
10744 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10745 if ( tmp2 == NULL )
10746 return NULL;
10747 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10748 {
10749 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10750 return NULL;
10751 }
10752 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10753 }
10754 {
10755 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10756 if ( tmp3 == NULL )
10757 return NULL;
10758 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10759 {
10760 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10761 return NULL;
10762 }
10763 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10764 }
10765 {
10766 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10767 if ( tmp4 == NULL )
10768 return NULL;
10769 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10770 {
10771 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10772 return NULL;
10773 }
10774 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10775 arg5 = PyArray_DIMS( tmp4 )[0];
10776 }
10777 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10778 resultobj = SWIG_Py_Void();
10779 {
10780 Py_CLEAR( tmp1 );
10781 }
10782 {
10783 Py_CLEAR( tmp2 );
10784 }
10785 {
10786 Py_CLEAR( tmp3 );
10787 }
10788 {
10789 Py_CLEAR( tmp4 );
10790 }
10791 return resultobj;
10792fail:
10793 {
10794 Py_CLEAR( tmp1 );
10795 }
10796 {
10797 Py_CLEAR( tmp2 );
10798 }
10799 {
10800 Py_CLEAR( tmp3 );
10801 }
10802 {
10803 Py_CLEAR( tmp4 );
10804 }
10805 return NULL;
10806}
10807
10808
10809SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *self, PyObject *args) {
10810 PyObject *resultobj = 0;
10811 PLINT arg1 ;
10812 int val1 ;
10813 int ecode1 = 0 ;
10814 PyObject *swig_obj[1] ;
10815
10816 (void)self;
10817 if (!args) SWIG_fail;
10818 swig_obj[0] = args;
10819 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10820 if (!SWIG_IsOK(ecode1)) {
10821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10822 }
10823 arg1 = (PLINT)(val1);
10824 plscmap0n(arg1);
10825 resultobj = SWIG_Py_Void();
10826 return resultobj;
10827fail:
10828 return NULL;
10829}
10830
10831
10832SWIGINTERN PyObject *_wrap_plscmap1(PyObject *self, PyObject *args) {
10833 PyObject *resultobj = 0;
10834 PLINT *arg1 = (PLINT *) 0 ;
10835 PLINT *arg2 = (PLINT *) 0 ;
10836 PLINT *arg3 = (PLINT *) 0 ;
10837 PLINT arg4 ;
10838 PyArrayObject *tmp1 = NULL ;
10839 PyArrayObject *tmp2 = NULL ;
10840 PyArrayObject *tmp3 = NULL ;
10841 PyObject *swig_obj[3] ;
10842
10843 (void)self;
10844 if (!SWIG_Python_UnpackTuple(args, "plscmap1", 3, 3, swig_obj)) SWIG_fail;
10845 {
10846 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10847 if ( tmp1 == NULL )
10848 return NULL;
10849 Alen = PyArray_DIMS( tmp1 )[0];
10850 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10851 }
10852 {
10853 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10854 if ( tmp2 == NULL )
10855 return NULL;
10856 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10857 {
10858 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10859 return NULL;
10860 }
10861 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10862 }
10863 {
10864 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10865 if ( tmp3 == NULL )
10866 return NULL;
10867 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10868 {
10869 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10870 return NULL;
10871 }
10872 arg4 = PyArray_DIMS( tmp3 )[0];
10873 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10874 }
10875 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10876 resultobj = SWIG_Py_Void();
10877 {
10878 Py_CLEAR( tmp1 );
10879 }
10880 {
10881 Py_CLEAR( tmp2 );
10882 }
10883 {
10884 Py_CLEAR( tmp3 );
10885 }
10886 return resultobj;
10887fail:
10888 {
10889 Py_CLEAR( tmp1 );
10890 }
10891 {
10892 Py_CLEAR( tmp2 );
10893 }
10894 {
10895 Py_CLEAR( tmp3 );
10896 }
10897 return NULL;
10898}
10899
10900
10901SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *self, PyObject *args) {
10902 PyObject *resultobj = 0;
10903 PLINT *arg1 = (PLINT *) 0 ;
10904 PLINT *arg2 = (PLINT *) 0 ;
10905 PLINT *arg3 = (PLINT *) 0 ;
10906 PLFLT *arg4 = (PLFLT *) 0 ;
10907 PLINT arg5 ;
10908 PyArrayObject *tmp1 = NULL ;
10909 PyArrayObject *tmp2 = NULL ;
10910 PyArrayObject *tmp3 = NULL ;
10911 PyArrayObject *tmp4 = NULL ;
10912 PyObject *swig_obj[4] ;
10913
10914 (void)self;
10915 if (!SWIG_Python_UnpackTuple(args, "plscmap1a", 4, 4, swig_obj)) SWIG_fail;
10916 {
10917 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10918 if ( tmp1 == NULL )
10919 return NULL;
10920 Alen = PyArray_DIMS( tmp1 )[0];
10921 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10922 }
10923 {
10924 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10925 if ( tmp2 == NULL )
10926 return NULL;
10927 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10928 {
10929 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10930 return NULL;
10931 }
10932 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10933 }
10934 {
10935 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10936 if ( tmp3 == NULL )
10937 return NULL;
10938 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10939 {
10940 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10941 return NULL;
10942 }
10943 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10944 }
10945 {
10946 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10947 if ( tmp4 == NULL )
10948 return NULL;
10949 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10950 {
10951 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10952 return NULL;
10953 }
10954 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10955 arg5 = PyArray_DIMS( tmp4 )[0];
10956 }
10957 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10958 resultobj = SWIG_Py_Void();
10959 {
10960 Py_CLEAR( tmp1 );
10961 }
10962 {
10963 Py_CLEAR( tmp2 );
10964 }
10965 {
10966 Py_CLEAR( tmp3 );
10967 }
10968 {
10969 Py_CLEAR( tmp4 );
10970 }
10971 return resultobj;
10972fail:
10973 {
10974 Py_CLEAR( tmp1 );
10975 }
10976 {
10977 Py_CLEAR( tmp2 );
10978 }
10979 {
10980 Py_CLEAR( tmp3 );
10981 }
10982 {
10983 Py_CLEAR( tmp4 );
10984 }
10985 return NULL;
10986}
10987
10988
10989SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *self, PyObject *args) {
10990 PyObject *resultobj = 0;
10991 PLBOOL arg1 ;
10992 PLINT arg2 ;
10993 PLFLT *arg3 = (PLFLT *) 0 ;
10994 PLFLT *arg4 = (PLFLT *) 0 ;
10995 PLFLT *arg5 = (PLFLT *) 0 ;
10996 PLFLT *arg6 = (PLFLT *) 0 ;
10997 PLBOOL *arg7 = (PLBOOL *) 0 ;
10998 int val1 ;
10999 int ecode1 = 0 ;
11000 PyArrayObject *tmp2 = NULL ;
11001 PyArrayObject *tmp4 = NULL ;
11002 PyArrayObject *tmp5 = NULL ;
11003 PyArrayObject *tmp6 = NULL ;
11004 PyArrayObject *tmp7 = NULL ;
11005 PyObject *swig_obj[6] ;
11006
11007 (void)self;
11008 if (!SWIG_Python_UnpackTuple(args, "plscmap1l", 6, 6, swig_obj)) SWIG_fail;
11009 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11010 if (!SWIG_IsOK(ecode1)) {
11011 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
11012 }
11013 arg1 = (PLBOOL)(val1);
11014 {
11015 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11016 if ( tmp2 == NULL )
11017 return NULL;
11018 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11019 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11020 }
11021 {
11022 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11023 if ( tmp4 == NULL )
11024 return NULL;
11025 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11026 {
11027 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11028 return NULL;
11029 }
11030 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11031 }
11032 {
11033 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11034 if ( tmp5 == NULL )
11035 return NULL;
11036 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11037 {
11038 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11039 return NULL;
11040 }
11041 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11042 }
11043 {
11044 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11045 if ( tmp6 == NULL )
11046 return NULL;
11047 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11048 {
11049 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11050 return NULL;
11051 }
11052 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11053 }
11054 {
11055 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[5], NPY_PLINT, 1, 1 );
11056 if ( tmp7 == NULL )
11057 return NULL;
11058 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
11059 {
11060 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11061 return NULL;
11062 }
11063 arg7 = (PLINT *) PyArray_DATA( tmp7 );
11064 }
11065 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
11066 resultobj = SWIG_Py_Void();
11067 {
11068 Py_CLEAR( tmp2 );
11069 }
11070 {
11071 Py_CLEAR( tmp4 );
11072 }
11073 {
11074 Py_CLEAR( tmp5 );
11075 }
11076 {
11077 Py_CLEAR( tmp6 );
11078 }
11079 {
11080 Py_CLEAR( tmp7 );
11081 }
11082 return resultobj;
11083fail:
11084 {
11085 Py_CLEAR( tmp2 );
11086 }
11087 {
11088 Py_CLEAR( tmp4 );
11089 }
11090 {
11091 Py_CLEAR( tmp5 );
11092 }
11093 {
11094 Py_CLEAR( tmp6 );
11095 }
11096 {
11097 Py_CLEAR( tmp7 );
11098 }
11099 return NULL;
11100}
11101
11102
11103SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *self, PyObject *args) {
11104 PyObject *resultobj = 0;
11105 PLBOOL arg1 ;
11106 PLINT arg2 ;
11107 PLFLT *arg3 = (PLFLT *) 0 ;
11108 PLFLT *arg4 = (PLFLT *) 0 ;
11109 PLFLT *arg5 = (PLFLT *) 0 ;
11110 PLFLT *arg6 = (PLFLT *) 0 ;
11111 PLFLT *arg7 = (PLFLT *) 0 ;
11112 PLBOOL *arg8 = (PLBOOL *) 0 ;
11113 int val1 ;
11114 int ecode1 = 0 ;
11115 PyArrayObject *tmp2 = NULL ;
11116 PyArrayObject *tmp4 = NULL ;
11117 PyArrayObject *tmp5 = NULL ;
11118 PyArrayObject *tmp6 = NULL ;
11119 PyArrayObject *tmp7 = NULL ;
11120 PyArrayObject *tmp8 = NULL ;
11121 PyObject *swig_obj[7] ;
11122
11123 (void)self;
11124 if (!SWIG_Python_UnpackTuple(args, "plscmap1la", 7, 7, swig_obj)) SWIG_fail;
11125 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11126 if (!SWIG_IsOK(ecode1)) {
11127 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
11128 }
11129 arg1 = (PLBOOL)(val1);
11130 {
11131 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11132 if ( tmp2 == NULL )
11133 return NULL;
11134 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11135 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11136 }
11137 {
11138 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11139 if ( tmp4 == NULL )
11140 return NULL;
11141 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11142 {
11143 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11144 return NULL;
11145 }
11146 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11147 }
11148 {
11149 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11150 if ( tmp5 == NULL )
11151 return NULL;
11152 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11153 {
11154 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11155 return NULL;
11156 }
11157 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11158 }
11159 {
11160 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11161 if ( tmp6 == NULL )
11162 return NULL;
11163 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11164 {
11165 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11166 return NULL;
11167 }
11168 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11169 }
11170 {
11171 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
11172 if ( tmp7 == NULL )
11173 return NULL;
11174 if ( PyArray_DIMS( tmp7 )[0] != Alen )
11175 {
11176 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11177 return NULL;
11178 }
11179 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
11180 }
11181 {
11182 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
11183 if ( tmp8 == NULL )
11184 return NULL;
11185 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
11186 {
11187 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11188 return NULL;
11189 }
11190 arg8 = (PLINT *) PyArray_DATA( tmp8 );
11191 }
11192 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
11193 resultobj = SWIG_Py_Void();
11194 {
11195 Py_CLEAR( tmp2 );
11196 }
11197 {
11198 Py_CLEAR( tmp4 );
11199 }
11200 {
11201 Py_CLEAR( tmp5 );
11202 }
11203 {
11204 Py_CLEAR( tmp6 );
11205 }
11206 {
11207 Py_CLEAR( tmp7 );
11208 }
11209 {
11210 Py_CLEAR( tmp8 );
11211 }
11212 return resultobj;
11213fail:
11214 {
11215 Py_CLEAR( tmp2 );
11216 }
11217 {
11218 Py_CLEAR( tmp4 );
11219 }
11220 {
11221 Py_CLEAR( tmp5 );
11222 }
11223 {
11224 Py_CLEAR( tmp6 );
11225 }
11226 {
11227 Py_CLEAR( tmp7 );
11228 }
11229 {
11230 Py_CLEAR( tmp8 );
11231 }
11232 return NULL;
11233}
11234
11235
11236SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *self, PyObject *args) {
11237 PyObject *resultobj = 0;
11238 PLINT arg1 ;
11239 int val1 ;
11240 int ecode1 = 0 ;
11241 PyObject *swig_obj[1] ;
11242
11243 (void)self;
11244 if (!args) SWIG_fail;
11245 swig_obj[0] = args;
11246 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11247 if (!SWIG_IsOK(ecode1)) {
11248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11249 }
11250 arg1 = (PLINT)(val1);
11251 plscmap1n(arg1);
11252 resultobj = SWIG_Py_Void();
11253 return resultobj;
11254fail:
11255 return NULL;
11256}
11257
11258
11259SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *self, PyObject *args) {
11260 PyObject *resultobj = 0;
11261 PLFLT arg1 ;
11262 PLFLT arg2 ;
11263 double val1 ;
11264 int ecode1 = 0 ;
11265 double val2 ;
11266 int ecode2 = 0 ;
11267 PyObject *swig_obj[2] ;
11268
11269 (void)self;
11270 if (!SWIG_Python_UnpackTuple(args, "plscmap1_range", 2, 2, swig_obj)) SWIG_fail;
11271 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11272 if (!SWIG_IsOK(ecode1)) {
11273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11274 }
11275 arg1 = (PLFLT)(val1);
11276 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11277 if (!SWIG_IsOK(ecode2)) {
11278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11279 }
11280 arg2 = (PLFLT)(val2);
11281 plscmap1_range(arg1,arg2);
11282 resultobj = SWIG_Py_Void();
11283 return resultobj;
11284fail:
11285 return NULL;
11286}
11287
11288
11289SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *self, PyObject *args) {
11290 PyObject *resultobj = 0;
11291 PLFLT *arg1 = (PLFLT *) 0 ;
11292 PLFLT *arg2 = (PLFLT *) 0 ;
11293 PLFLT temp1 ;
11294 int res1 = SWIG_TMPOBJ ;
11295 PLFLT temp2 ;
11296 int res2 = SWIG_TMPOBJ ;
11297
11298 arg1 = &temp1;
11299 arg2 = &temp2;
11300 (void)self;
11301 if (!SWIG_Python_UnpackTuple(args, "plgcmap1_range", 0, 0, 0)) SWIG_fail;
11302 plgcmap1_range(arg1,arg2);
11303 resultobj = SWIG_Py_Void();
11304 if (SWIG_IsTmpObj(res1)) {
11305 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
11306 } else {
11307 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11308 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11309 }
11310 if (SWIG_IsTmpObj(res2)) {
11311 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
11312 } else {
11313 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11314 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11315 }
11316 return resultobj;
11317fail:
11318 return NULL;
11319}
11320
11321
11322SWIGINTERN PyObject *_wrap_plscol0(PyObject *self, PyObject *args) {
11323 PyObject *resultobj = 0;
11324 PLINT arg1 ;
11325 PLINT arg2 ;
11326 PLINT arg3 ;
11327 PLINT arg4 ;
11328 int val1 ;
11329 int ecode1 = 0 ;
11330 int val2 ;
11331 int ecode2 = 0 ;
11332 int val3 ;
11333 int ecode3 = 0 ;
11334 int val4 ;
11335 int ecode4 = 0 ;
11336 PyObject *swig_obj[4] ;
11337
11338 (void)self;
11339 if (!SWIG_Python_UnpackTuple(args, "plscol0", 4, 4, swig_obj)) SWIG_fail;
11340 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11341 if (!SWIG_IsOK(ecode1)) {
11342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11343 }
11344 arg1 = (PLINT)(val1);
11345 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11346 if (!SWIG_IsOK(ecode2)) {
11347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11348 }
11349 arg2 = (PLINT)(val2);
11350 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11351 if (!SWIG_IsOK(ecode3)) {
11352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11353 }
11354 arg3 = (PLINT)(val3);
11355 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11356 if (!SWIG_IsOK(ecode4)) {
11357 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11358 }
11359 arg4 = (PLINT)(val4);
11360 plscol0(arg1,arg2,arg3,arg4);
11361 resultobj = SWIG_Py_Void();
11362 return resultobj;
11363fail:
11364 return NULL;
11365}
11366
11367
11368SWIGINTERN PyObject *_wrap_plscol0a(PyObject *self, PyObject *args) {
11369 PyObject *resultobj = 0;
11370 PLINT arg1 ;
11371 PLINT arg2 ;
11372 PLINT arg3 ;
11373 PLINT arg4 ;
11374 PLFLT arg5 ;
11375 int val1 ;
11376 int ecode1 = 0 ;
11377 int val2 ;
11378 int ecode2 = 0 ;
11379 int val3 ;
11380 int ecode3 = 0 ;
11381 int val4 ;
11382 int ecode4 = 0 ;
11383 double val5 ;
11384 int ecode5 = 0 ;
11385 PyObject *swig_obj[5] ;
11386
11387 (void)self;
11388 if (!SWIG_Python_UnpackTuple(args, "plscol0a", 5, 5, swig_obj)) SWIG_fail;
11389 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11390 if (!SWIG_IsOK(ecode1)) {
11391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11392 }
11393 arg1 = (PLINT)(val1);
11394 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11395 if (!SWIG_IsOK(ecode2)) {
11396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11397 }
11398 arg2 = (PLINT)(val2);
11399 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11400 if (!SWIG_IsOK(ecode3)) {
11401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11402 }
11403 arg3 = (PLINT)(val3);
11404 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11405 if (!SWIG_IsOK(ecode4)) {
11406 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11407 }
11408 arg4 = (PLINT)(val4);
11409 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11410 if (!SWIG_IsOK(ecode5)) {
11411 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11412 }
11413 arg5 = (PLFLT)(val5);
11414 plscol0a(arg1,arg2,arg3,arg4,arg5);
11415 resultobj = SWIG_Py_Void();
11416 return resultobj;
11417fail:
11418 return NULL;
11419}
11420
11421
11422SWIGINTERN PyObject *_wrap_plscolbg(PyObject *self, PyObject *args) {
11423 PyObject *resultobj = 0;
11424 PLINT arg1 ;
11425 PLINT arg2 ;
11426 PLINT arg3 ;
11427 int val1 ;
11428 int ecode1 = 0 ;
11429 int val2 ;
11430 int ecode2 = 0 ;
11431 int val3 ;
11432 int ecode3 = 0 ;
11433 PyObject *swig_obj[3] ;
11434
11435 (void)self;
11436 if (!SWIG_Python_UnpackTuple(args, "plscolbg", 3, 3, swig_obj)) SWIG_fail;
11437 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11438 if (!SWIG_IsOK(ecode1)) {
11439 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11440 }
11441 arg1 = (PLINT)(val1);
11442 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11443 if (!SWIG_IsOK(ecode2)) {
11444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11445 }
11446 arg2 = (PLINT)(val2);
11447 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11448 if (!SWIG_IsOK(ecode3)) {
11449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11450 }
11451 arg3 = (PLINT)(val3);
11452 plscolbg(arg1,arg2,arg3);
11453 resultobj = SWIG_Py_Void();
11454 return resultobj;
11455fail:
11456 return NULL;
11457}
11458
11459
11460SWIGINTERN PyObject *_wrap_plscolbga(PyObject *self, PyObject *args) {
11461 PyObject *resultobj = 0;
11462 PLINT arg1 ;
11463 PLINT arg2 ;
11464 PLINT arg3 ;
11465 PLFLT arg4 ;
11466 int val1 ;
11467 int ecode1 = 0 ;
11468 int val2 ;
11469 int ecode2 = 0 ;
11470 int val3 ;
11471 int ecode3 = 0 ;
11472 double val4 ;
11473 int ecode4 = 0 ;
11474 PyObject *swig_obj[4] ;
11475
11476 (void)self;
11477 if (!SWIG_Python_UnpackTuple(args, "plscolbga", 4, 4, swig_obj)) SWIG_fail;
11478 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11479 if (!SWIG_IsOK(ecode1)) {
11480 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11481 }
11482 arg1 = (PLINT)(val1);
11483 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11484 if (!SWIG_IsOK(ecode2)) {
11485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11486 }
11487 arg2 = (PLINT)(val2);
11488 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11489 if (!SWIG_IsOK(ecode3)) {
11490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11491 }
11492 arg3 = (PLINT)(val3);
11493 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11494 if (!SWIG_IsOK(ecode4)) {
11495 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11496 }
11497 arg4 = (PLFLT)(val4);
11498 plscolbga(arg1,arg2,arg3,arg4);
11499 resultobj = SWIG_Py_Void();
11500 return resultobj;
11501fail:
11502 return NULL;
11503}
11504
11505
11506SWIGINTERN PyObject *_wrap_plscolor(PyObject *self, PyObject *args) {
11507 PyObject *resultobj = 0;
11508 PLINT arg1 ;
11509 int val1 ;
11510 int ecode1 = 0 ;
11511 PyObject *swig_obj[1] ;
11512
11513 (void)self;
11514 if (!args) SWIG_fail;
11515 swig_obj[0] = args;
11516 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11517 if (!SWIG_IsOK(ecode1)) {
11518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11519 }
11520 arg1 = (PLINT)(val1);
11521 plscolor(arg1);
11522 resultobj = SWIG_Py_Void();
11523 return resultobj;
11524fail:
11525 return NULL;
11526}
11527
11528
11529SWIGINTERN PyObject *_wrap_plscompression(PyObject *self, PyObject *args) {
11530 PyObject *resultobj = 0;
11531 PLINT arg1 ;
11532 int val1 ;
11533 int ecode1 = 0 ;
11534 PyObject *swig_obj[1] ;
11535
11536 (void)self;
11537 if (!args) SWIG_fail;
11538 swig_obj[0] = args;
11539 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11540 if (!SWIG_IsOK(ecode1)) {
11541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11542 }
11543 arg1 = (PLINT)(val1);
11544 plscompression(arg1);
11545 resultobj = SWIG_Py_Void();
11546 return resultobj;
11547fail:
11548 return NULL;
11549}
11550
11551
11552SWIGINTERN PyObject *_wrap_plsdev(PyObject *self, PyObject *args) {
11553 PyObject *resultobj = 0;
11554 char *arg1 = (char *) 0 ;
11555 int res1 ;
11556 char *buf1 = 0 ;
11557 int alloc1 = 0 ;
11558 PyObject *swig_obj[1] ;
11559
11560 (void)self;
11561 if (!args) SWIG_fail;
11562 swig_obj[0] = args;
11563 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11564 if (!SWIG_IsOK(res1)) {
11565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11566 }
11567 arg1 = (char *)(buf1);
11568 plsdev((char const *)arg1);
11569 resultobj = SWIG_Py_Void();
11570 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11571 return resultobj;
11572fail:
11573 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11574 return NULL;
11575}
11576
11577
11578SWIGINTERN PyObject *_wrap_plsdidev(PyObject *self, PyObject *args) {
11579 PyObject *resultobj = 0;
11580 PLFLT arg1 ;
11581 PLFLT arg2 ;
11582 PLFLT arg3 ;
11583 PLFLT arg4 ;
11584 double val1 ;
11585 int ecode1 = 0 ;
11586 double val2 ;
11587 int ecode2 = 0 ;
11588 double val3 ;
11589 int ecode3 = 0 ;
11590 double val4 ;
11591 int ecode4 = 0 ;
11592 PyObject *swig_obj[4] ;
11593
11594 (void)self;
11595 if (!SWIG_Python_UnpackTuple(args, "plsdidev", 4, 4, swig_obj)) SWIG_fail;
11596 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11597 if (!SWIG_IsOK(ecode1)) {
11598 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11599 }
11600 arg1 = (PLFLT)(val1);
11601 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11602 if (!SWIG_IsOK(ecode2)) {
11603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11604 }
11605 arg2 = (PLFLT)(val2);
11606 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11607 if (!SWIG_IsOK(ecode3)) {
11608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11609 }
11610 arg3 = (PLFLT)(val3);
11611 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11612 if (!SWIG_IsOK(ecode4)) {
11613 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11614 }
11615 arg4 = (PLFLT)(val4);
11616 plsdidev(arg1,arg2,arg3,arg4);
11617 resultobj = SWIG_Py_Void();
11618 return resultobj;
11619fail:
11620 return NULL;
11621}
11622
11623
11624SWIGINTERN PyObject *_wrap_plsdimap(PyObject *self, PyObject *args) {
11625 PyObject *resultobj = 0;
11626 PLINT arg1 ;
11627 PLINT arg2 ;
11628 PLINT arg3 ;
11629 PLINT arg4 ;
11630 PLFLT arg5 ;
11631 PLFLT arg6 ;
11632 int val1 ;
11633 int ecode1 = 0 ;
11634 int val2 ;
11635 int ecode2 = 0 ;
11636 int val3 ;
11637 int ecode3 = 0 ;
11638 int val4 ;
11639 int ecode4 = 0 ;
11640 double val5 ;
11641 int ecode5 = 0 ;
11642 double val6 ;
11643 int ecode6 = 0 ;
11644 PyObject *swig_obj[6] ;
11645
11646 (void)self;
11647 if (!SWIG_Python_UnpackTuple(args, "plsdimap", 6, 6, swig_obj)) SWIG_fail;
11648 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11649 if (!SWIG_IsOK(ecode1)) {
11650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11651 }
11652 arg1 = (PLINT)(val1);
11653 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11654 if (!SWIG_IsOK(ecode2)) {
11655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11656 }
11657 arg2 = (PLINT)(val2);
11658 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11659 if (!SWIG_IsOK(ecode3)) {
11660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11661 }
11662 arg3 = (PLINT)(val3);
11663 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11664 if (!SWIG_IsOK(ecode4)) {
11665 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11666 }
11667 arg4 = (PLINT)(val4);
11668 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11669 if (!SWIG_IsOK(ecode5)) {
11670 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11671 }
11672 arg5 = (PLFLT)(val5);
11673 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
11674 if (!SWIG_IsOK(ecode6)) {
11675 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11676 }
11677 arg6 = (PLFLT)(val6);
11678 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11679 resultobj = SWIG_Py_Void();
11680 return resultobj;
11681fail:
11682 return NULL;
11683}
11684
11685
11686SWIGINTERN PyObject *_wrap_plsdiori(PyObject *self, PyObject *args) {
11687 PyObject *resultobj = 0;
11688 PLFLT arg1 ;
11689 double val1 ;
11690 int ecode1 = 0 ;
11691 PyObject *swig_obj[1] ;
11692
11693 (void)self;
11694 if (!args) SWIG_fail;
11695 swig_obj[0] = args;
11696 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11697 if (!SWIG_IsOK(ecode1)) {
11698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11699 }
11700 arg1 = (PLFLT)(val1);
11701 plsdiori(arg1);
11702 resultobj = SWIG_Py_Void();
11703 return resultobj;
11704fail:
11705 return NULL;
11706}
11707
11708
11709SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *self, PyObject *args) {
11710 PyObject *resultobj = 0;
11711 PLFLT arg1 ;
11712 PLFLT arg2 ;
11713 PLFLT arg3 ;
11714 PLFLT arg4 ;
11715 double val1 ;
11716 int ecode1 = 0 ;
11717 double val2 ;
11718 int ecode2 = 0 ;
11719 double val3 ;
11720 int ecode3 = 0 ;
11721 double val4 ;
11722 int ecode4 = 0 ;
11723 PyObject *swig_obj[4] ;
11724
11725 (void)self;
11726 if (!SWIG_Python_UnpackTuple(args, "plsdiplt", 4, 4, swig_obj)) SWIG_fail;
11727 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11728 if (!SWIG_IsOK(ecode1)) {
11729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11730 }
11731 arg1 = (PLFLT)(val1);
11732 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11733 if (!SWIG_IsOK(ecode2)) {
11734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11735 }
11736 arg2 = (PLFLT)(val2);
11737 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11738 if (!SWIG_IsOK(ecode3)) {
11739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11740 }
11741 arg3 = (PLFLT)(val3);
11742 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11743 if (!SWIG_IsOK(ecode4)) {
11744 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11745 }
11746 arg4 = (PLFLT)(val4);
11747 plsdiplt(arg1,arg2,arg3,arg4);
11748 resultobj = SWIG_Py_Void();
11749 return resultobj;
11750fail:
11751 return NULL;
11752}
11753
11754
11755SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *self, PyObject *args) {
11756 PyObject *resultobj = 0;
11757 PLFLT arg1 ;
11758 PLFLT arg2 ;
11759 PLFLT arg3 ;
11760 PLFLT arg4 ;
11761 double val1 ;
11762 int ecode1 = 0 ;
11763 double val2 ;
11764 int ecode2 = 0 ;
11765 double val3 ;
11766 int ecode3 = 0 ;
11767 double val4 ;
11768 int ecode4 = 0 ;
11769 PyObject *swig_obj[4] ;
11770
11771 (void)self;
11772 if (!SWIG_Python_UnpackTuple(args, "plsdiplz", 4, 4, swig_obj)) SWIG_fail;
11773 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11774 if (!SWIG_IsOK(ecode1)) {
11775 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11776 }
11777 arg1 = (PLFLT)(val1);
11778 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11779 if (!SWIG_IsOK(ecode2)) {
11780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11781 }
11782 arg2 = (PLFLT)(val2);
11783 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11784 if (!SWIG_IsOK(ecode3)) {
11785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11786 }
11787 arg3 = (PLFLT)(val3);
11788 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11789 if (!SWIG_IsOK(ecode4)) {
11790 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11791 }
11792 arg4 = (PLFLT)(val4);
11793 plsdiplz(arg1,arg2,arg3,arg4);
11794 resultobj = SWIG_Py_Void();
11795 return resultobj;
11796fail:
11797 return NULL;
11798}
11799
11800
11801SWIGINTERN PyObject *_wrap_plseed(PyObject *self, PyObject *args) {
11802 PyObject *resultobj = 0;
11803 unsigned int arg1 ;
11804 unsigned int val1 ;
11805 int ecode1 = 0 ;
11806 PyObject *swig_obj[1] ;
11807
11808 (void)self;
11809 if (!args) SWIG_fail;
11810 swig_obj[0] = args;
11811 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11812 if (!SWIG_IsOK(ecode1)) {
11813 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11814 }
11815 arg1 = (unsigned int)(val1);
11816 plseed(arg1);
11817 resultobj = SWIG_Py_Void();
11818 return resultobj;
11819fail:
11820 return NULL;
11821}
11822
11823
11824SWIGINTERN PyObject *_wrap_plsesc(PyObject *self, PyObject *args) {
11825 PyObject *resultobj = 0;
11826 char arg1 ;
11827 char val1 ;
11828 int ecode1 = 0 ;
11829 PyObject *swig_obj[1] ;
11830
11831 (void)self;
11832 if (!args) SWIG_fail;
11833 swig_obj[0] = args;
11834 ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
11835 if (!SWIG_IsOK(ecode1)) {
11836 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11837 }
11838 arg1 = (char)(val1);
11839 plsesc(arg1);
11840 resultobj = SWIG_Py_Void();
11841 return resultobj;
11842fail:
11843 return NULL;
11844}
11845
11846
11847SWIGINTERN PyObject *_wrap_plsetopt(PyObject *self, PyObject *args) {
11848 PyObject *resultobj = 0;
11849 char *arg1 = (char *) 0 ;
11850 char *arg2 = (char *) 0 ;
11851 int res1 ;
11852 char *buf1 = 0 ;
11853 int alloc1 = 0 ;
11854 int res2 ;
11855 char *buf2 = 0 ;
11856 int alloc2 = 0 ;
11857 PyObject *swig_obj[2] ;
11858 PLINT result;
11859
11860 (void)self;
11861 if (!SWIG_Python_UnpackTuple(args, "plsetopt", 2, 2, swig_obj)) SWIG_fail;
11862 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11863 if (!SWIG_IsOK(res1)) {
11864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11865 }
11866 arg1 = (char *)(buf1);
11867 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11868 if (!SWIG_IsOK(res2)) {
11869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11870 }
11871 arg2 = (char *)(buf2);
11872 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11873 resultobj = SWIG_From_int((int)(result));
11874 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11875 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11876 return resultobj;
11877fail:
11878 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11879 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11880 return NULL;
11881}
11882
11883
11884SWIGINTERN PyObject *_wrap_plsfam(PyObject *self, PyObject *args) {
11885 PyObject *resultobj = 0;
11886 PLINT arg1 ;
11887 PLINT arg2 ;
11888 PLINT arg3 ;
11889 int val1 ;
11890 int ecode1 = 0 ;
11891 int val2 ;
11892 int ecode2 = 0 ;
11893 int val3 ;
11894 int ecode3 = 0 ;
11895 PyObject *swig_obj[3] ;
11896
11897 (void)self;
11898 if (!SWIG_Python_UnpackTuple(args, "plsfam", 3, 3, swig_obj)) SWIG_fail;
11899 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11900 if (!SWIG_IsOK(ecode1)) {
11901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11902 }
11903 arg1 = (PLINT)(val1);
11904 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11905 if (!SWIG_IsOK(ecode2)) {
11906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11907 }
11908 arg2 = (PLINT)(val2);
11909 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11910 if (!SWIG_IsOK(ecode3)) {
11911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11912 }
11913 arg3 = (PLINT)(val3);
11914 plsfam(arg1,arg2,arg3);
11915 resultobj = SWIG_Py_Void();
11916 return resultobj;
11917fail:
11918 return NULL;
11919}
11920
11921
11922SWIGINTERN PyObject *_wrap_plsfci(PyObject *self, PyObject *args) {
11923 PyObject *resultobj = 0;
11924 PLUNICODE arg1 ;
11925 unsigned int val1 ;
11926 int ecode1 = 0 ;
11927 PyObject *swig_obj[1] ;
11928
11929 (void)self;
11930 if (!args) SWIG_fail;
11931 swig_obj[0] = args;
11932 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11933 if (!SWIG_IsOK(ecode1)) {
11934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11935 }
11936 arg1 = (PLUNICODE)(val1);
11937 plsfci(arg1);
11938 resultobj = SWIG_Py_Void();
11939 return resultobj;
11940fail:
11941 return NULL;
11942}
11943
11944
11945SWIGINTERN PyObject *_wrap_plsfnam(PyObject *self, PyObject *args) {
11946 PyObject *resultobj = 0;
11947 char *arg1 = (char *) 0 ;
11948 int res1 ;
11949 char *buf1 = 0 ;
11950 int alloc1 = 0 ;
11951 PyObject *swig_obj[1] ;
11952
11953 (void)self;
11954 if (!args) SWIG_fail;
11955 swig_obj[0] = args;
11956 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11957 if (!SWIG_IsOK(res1)) {
11958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11959 }
11960 arg1 = (char *)(buf1);
11961 plsfnam((char const *)arg1);
11962 resultobj = SWIG_Py_Void();
11963 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11964 return resultobj;
11965fail:
11966 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11967 return NULL;
11968}
11969
11970
11971SWIGINTERN PyObject *_wrap_plsfont(PyObject *self, PyObject *args) {
11972 PyObject *resultobj = 0;
11973 PLINT arg1 ;
11974 PLINT arg2 ;
11975 PLINT arg3 ;
11976 int val1 ;
11977 int ecode1 = 0 ;
11978 int val2 ;
11979 int ecode2 = 0 ;
11980 int val3 ;
11981 int ecode3 = 0 ;
11982 PyObject *swig_obj[3] ;
11983
11984 (void)self;
11985 if (!SWIG_Python_UnpackTuple(args, "plsfont", 3, 3, swig_obj)) SWIG_fail;
11986 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11987 if (!SWIG_IsOK(ecode1)) {
11988 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11989 }
11990 arg1 = (PLINT)(val1);
11991 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11992 if (!SWIG_IsOK(ecode2)) {
11993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11994 }
11995 arg2 = (PLINT)(val2);
11996 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11997 if (!SWIG_IsOK(ecode3)) {
11998 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11999 }
12000 arg3 = (PLINT)(val3);
12001 plsfont(arg1,arg2,arg3);
12002 resultobj = SWIG_Py_Void();
12003 return resultobj;
12004fail:
12005 return NULL;
12006}
12007
12008
12009SWIGINTERN PyObject *_wrap_plshades(PyObject *self, PyObject *args) {
12010 PyObject *resultobj = 0;
12011 PLFLT **arg1 = (PLFLT **) 0 ;
12012 PLINT arg2 ;
12013 PLINT arg3 ;
12014 defined_func arg4 = (defined_func) 0 ;
12015 PLFLT arg5 ;
12016 PLFLT arg6 ;
12017 PLFLT arg7 ;
12018 PLFLT arg8 ;
12019 PLFLT *arg9 = (PLFLT *) 0 ;
12020 PLINT arg10 ;
12021 PLFLT arg11 ;
12022 PLINT arg12 ;
12023 PLFLT arg13 ;
12024 fill_func arg14 = (fill_func) 0 ;
12025 PLBOOL arg15 ;
12026 pltr_func arg16 = (pltr_func) 0 ;
12027 PLPointer arg17 = (PLPointer) 0 ;
12028 PyArrayObject *tmp1 = NULL ;
12029 double val5 ;
12030 int ecode5 = 0 ;
12031 double val6 ;
12032 int ecode6 = 0 ;
12033 double val7 ;
12034 int ecode7 = 0 ;
12035 double val8 ;
12036 int ecode8 = 0 ;
12037 PyArrayObject *tmp9 = NULL ;
12038 double val11 ;
12039 int ecode11 = 0 ;
12040 int val12 ;
12041 int ecode12 = 0 ;
12042 double val13 ;
12043 int ecode13 = 0 ;
12044 int val15 ;
12045 int ecode15 = 0 ;
12046 PyObject *swig_obj[12] ;
12047
12048 {
12049 python_pltr = 0;
12050 arg16 = NULL;
12051 }
12052 {
12053 arg17 = NULL;
12054 }
12055 {
12056 arg4 = NULL;
12057 }
12058 {
12059 arg14 = plfill;
12060 }
12061 (void)self;
12062 if (!SWIG_Python_UnpackTuple(args, "plshades", 10, 12, swig_obj)) SWIG_fail;
12063 {
12064 int i, size;
12065 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12066 if ( tmp1 == NULL )
12067 return NULL;
12068 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12069 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12070 size = arg3;
12071 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12072 for ( i = 0; i < arg2; i++ )
12073 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12074 }
12075 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12076 if (!SWIG_IsOK(ecode5)) {
12077 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
12078 }
12079 arg5 = (PLFLT)(val5);
12080 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12081 if (!SWIG_IsOK(ecode6)) {
12082 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
12083 }
12084 arg6 = (PLFLT)(val6);
12085 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12086 if (!SWIG_IsOK(ecode7)) {
12087 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
12088 }
12089 arg7 = (PLFLT)(val7);
12090 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12091 if (!SWIG_IsOK(ecode8)) {
12092 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
12093 }
12094 arg8 = (PLFLT)(val8);
12095 {
12096 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
12097 if ( tmp9 == NULL )
12098 return NULL;
12099 arg10 = PyArray_DIMS( tmp9 )[0];
12100 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
12101 }
12102 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
12103 if (!SWIG_IsOK(ecode11)) {
12104 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
12105 }
12106 arg11 = (PLFLT)(val11);
12107 ecode12 = SWIG_AsVal_int(swig_obj[7], &val12);
12108 if (!SWIG_IsOK(ecode12)) {
12109 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
12110 }
12111 arg12 = (PLINT)(val12);
12112 ecode13 = SWIG_AsVal_double(swig_obj[8], &val13);
12113 if (!SWIG_IsOK(ecode13)) {
12114 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
12115 }
12116 arg13 = (PLFLT)(val13);
12117 ecode15 = SWIG_AsVal_int(swig_obj[9], &val15);
12118 if (!SWIG_IsOK(ecode15)) {
12119 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
12120 }
12121 arg15 = (PLBOOL)(val15);
12122 if (swig_obj[10]) {
12123 {
12124 // it must be a callable or None
12125 if ( swig_obj[10] == Py_None )
12126 {
12127 arg16 = NULL;
12128 }
12129 else
12130 {
12131 if ( !PyCallable_Check( (PyObject *) swig_obj[10] ) )
12132 {
12133 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12134 return NULL;
12135 }
12136 arg16 = marshal_pltr( swig_obj[10] );
12137 }
12138 }
12139 }
12140 if (swig_obj[11]) {
12141 {
12142 if ( swig_obj[11] == Py_None )
12143 arg17 = NULL;
12144 else
12145 {
12146 arg17 = marshal_PLPointer( swig_obj[11], 0 );
12147 }
12148 }
12149 }
12150 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
12151 resultobj = SWIG_Py_Void();
12152 {
12153 Py_CLEAR( tmp1 );
12154 free( arg1 );
12155 }
12156 {
12157 Py_CLEAR( tmp9 );
12158 }
12159 {
12160 cleanup_pltr();
12161 }
12162 {
12164 }
12165 return resultobj;
12166fail:
12167 {
12168 Py_CLEAR( tmp1 );
12169 free( arg1 );
12170 }
12171 {
12172 Py_CLEAR( tmp9 );
12173 }
12174 {
12175 cleanup_pltr();
12176 }
12177 {
12179 }
12180 return NULL;
12181}
12182
12183
12184SWIGINTERN PyObject *_wrap_plshade(PyObject *self, PyObject *args) {
12185 PyObject *resultobj = 0;
12186 PLFLT **arg1 = (PLFLT **) 0 ;
12187 PLINT arg2 ;
12188 PLINT arg3 ;
12189 defined_func arg4 = (defined_func) 0 ;
12190 PLFLT arg5 ;
12191 PLFLT arg6 ;
12192 PLFLT arg7 ;
12193 PLFLT arg8 ;
12194 PLFLT arg9 ;
12195 PLFLT arg10 ;
12196 PLINT arg11 ;
12197 PLFLT arg12 ;
12198 PLFLT arg13 ;
12199 PLINT arg14 ;
12200 PLFLT arg15 ;
12201 PLINT arg16 ;
12202 PLFLT arg17 ;
12203 fill_func arg18 = (fill_func) 0 ;
12204 PLBOOL arg19 ;
12205 pltr_func arg20 = (pltr_func) 0 ;
12206 PLPointer arg21 = (PLPointer) 0 ;
12207 PyArrayObject *tmp1 = NULL ;
12208 double val5 ;
12209 int ecode5 = 0 ;
12210 double val6 ;
12211 int ecode6 = 0 ;
12212 double val7 ;
12213 int ecode7 = 0 ;
12214 double val8 ;
12215 int ecode8 = 0 ;
12216 double val9 ;
12217 int ecode9 = 0 ;
12218 double val10 ;
12219 int ecode10 = 0 ;
12220 int val11 ;
12221 int ecode11 = 0 ;
12222 double val12 ;
12223 int ecode12 = 0 ;
12224 double val13 ;
12225 int ecode13 = 0 ;
12226 int val14 ;
12227 int ecode14 = 0 ;
12228 double val15 ;
12229 int ecode15 = 0 ;
12230 int val16 ;
12231 int ecode16 = 0 ;
12232 double val17 ;
12233 int ecode17 = 0 ;
12234 int val19 ;
12235 int ecode19 = 0 ;
12236 PyObject *swig_obj[17] ;
12237
12238 {
12239 python_pltr = 0;
12240 arg20 = NULL;
12241 }
12242 {
12243 arg21 = NULL;
12244 }
12245 {
12246 arg4 = NULL;
12247 }
12248 {
12249 arg18 = plfill;
12250 }
12251 (void)self;
12252 if (!SWIG_Python_UnpackTuple(args, "plshade", 15, 17, swig_obj)) SWIG_fail;
12253 {
12254 int i, size;
12255 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12256 if ( tmp1 == NULL )
12257 return NULL;
12258 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12259 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12260 size = arg3;
12261 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12262 for ( i = 0; i < arg2; i++ )
12263 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12264 }
12265 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12266 if (!SWIG_IsOK(ecode5)) {
12267 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12268 }
12269 arg5 = (PLFLT)(val5);
12270 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12271 if (!SWIG_IsOK(ecode6)) {
12272 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12273 }
12274 arg6 = (PLFLT)(val6);
12275 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12276 if (!SWIG_IsOK(ecode7)) {
12277 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12278 }
12279 arg7 = (PLFLT)(val7);
12280 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12281 if (!SWIG_IsOK(ecode8)) {
12282 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12283 }
12284 arg8 = (PLFLT)(val8);
12285 ecode9 = SWIG_AsVal_double(swig_obj[5], &val9);
12286 if (!SWIG_IsOK(ecode9)) {
12287 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12288 }
12289 arg9 = (PLFLT)(val9);
12290 ecode10 = SWIG_AsVal_double(swig_obj[6], &val10);
12291 if (!SWIG_IsOK(ecode10)) {
12292 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12293 }
12294 arg10 = (PLFLT)(val10);
12295 ecode11 = SWIG_AsVal_int(swig_obj[7], &val11);
12296 if (!SWIG_IsOK(ecode11)) {
12297 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12298 }
12299 arg11 = (PLINT)(val11);
12300 ecode12 = SWIG_AsVal_double(swig_obj[8], &val12);
12301 if (!SWIG_IsOK(ecode12)) {
12302 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12303 }
12304 arg12 = (PLFLT)(val12);
12305 ecode13 = SWIG_AsVal_double(swig_obj[9], &val13);
12306 if (!SWIG_IsOK(ecode13)) {
12307 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12308 }
12309 arg13 = (PLFLT)(val13);
12310 ecode14 = SWIG_AsVal_int(swig_obj[10], &val14);
12311 if (!SWIG_IsOK(ecode14)) {
12312 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12313 }
12314 arg14 = (PLINT)(val14);
12315 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
12316 if (!SWIG_IsOK(ecode15)) {
12317 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12318 }
12319 arg15 = (PLFLT)(val15);
12320 ecode16 = SWIG_AsVal_int(swig_obj[12], &val16);
12321 if (!SWIG_IsOK(ecode16)) {
12322 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12323 }
12324 arg16 = (PLINT)(val16);
12325 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
12326 if (!SWIG_IsOK(ecode17)) {
12327 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12328 }
12329 arg17 = (PLFLT)(val17);
12330 ecode19 = SWIG_AsVal_int(swig_obj[14], &val19);
12331 if (!SWIG_IsOK(ecode19)) {
12332 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12333 }
12334 arg19 = (PLBOOL)(val19);
12335 if (swig_obj[15]) {
12336 {
12337 // it must be a callable or None
12338 if ( swig_obj[15] == Py_None )
12339 {
12340 arg20 = NULL;
12341 }
12342 else
12343 {
12344 if ( !PyCallable_Check( (PyObject *) swig_obj[15] ) )
12345 {
12346 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12347 return NULL;
12348 }
12349 arg20 = marshal_pltr( swig_obj[15] );
12350 }
12351 }
12352 }
12353 if (swig_obj[16]) {
12354 {
12355 if ( swig_obj[16] == Py_None )
12356 arg21 = NULL;
12357 else
12358 {
12359 arg21 = marshal_PLPointer( swig_obj[16], 0 );
12360 }
12361 }
12362 }
12363 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12364 resultobj = SWIG_Py_Void();
12365 {
12366 Py_CLEAR( tmp1 );
12367 free( arg1 );
12368 }
12369 {
12370 cleanup_pltr();
12371 }
12372 {
12374 }
12375 return resultobj;
12376fail:
12377 {
12378 Py_CLEAR( tmp1 );
12379 free( arg1 );
12380 }
12381 {
12382 cleanup_pltr();
12383 }
12384 {
12386 }
12387 return NULL;
12388}
12389
12390
12391SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *self, PyObject *args) {
12392 PyObject *resultobj = 0;
12393 label_func arg1 = (label_func) 0 ;
12394 PLPointer arg2 = (PLPointer) 0 ;
12395 int res2 ;
12396 PyObject *swig_obj[2] ;
12397
12398 (void)self;
12399 if (!SWIG_Python_UnpackTuple(args, "plslabelfunc", 2, 2, swig_obj)) SWIG_fail;
12400 {
12401 // Release reference to previous function if applicable
12402 if ( python_label )
12403 {
12404 Py_CLEAR( python_label );
12405 python_label = 0;
12406 }
12407 // it must be a callable or None
12408 if ( swig_obj[0] == Py_None )
12409 {
12410 arg1 = NULL;
12411 }
12412 else
12413 {
12414 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12415 {
12416 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12417 return NULL;
12418 }
12419 // hold a reference to it
12420 Py_XINCREF( (PyObject *) swig_obj[0] );
12421 python_label = (PyObject *) swig_obj[0];
12422 // this function handles calling the python function
12423 arg1 = do_label_callback;
12424 }
12425 }
12426 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12427 if (!SWIG_IsOK(res2)) {
12428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12429 }
12430 plslabelfunc(arg1,arg2);
12431 resultobj = SWIG_Py_Void();
12432 return resultobj;
12433fail:
12434 return NULL;
12435}
12436
12437
12438SWIGINTERN PyObject *_wrap_plsmaj(PyObject *self, PyObject *args) {
12439 PyObject *resultobj = 0;
12440 PLFLT arg1 ;
12441 PLFLT arg2 ;
12442 double val1 ;
12443 int ecode1 = 0 ;
12444 double val2 ;
12445 int ecode2 = 0 ;
12446 PyObject *swig_obj[2] ;
12447
12448 (void)self;
12449 if (!SWIG_Python_UnpackTuple(args, "plsmaj", 2, 2, swig_obj)) SWIG_fail;
12450 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12451 if (!SWIG_IsOK(ecode1)) {
12452 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12453 }
12454 arg1 = (PLFLT)(val1);
12455 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12456 if (!SWIG_IsOK(ecode2)) {
12457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12458 }
12459 arg2 = (PLFLT)(val2);
12460 plsmaj(arg1,arg2);
12461 resultobj = SWIG_Py_Void();
12462 return resultobj;
12463fail:
12464 return NULL;
12465}
12466
12467
12468SWIGINTERN PyObject *_wrap_plsmem(PyObject *self, PyObject *args) {
12469 PyObject *resultobj = 0;
12470 PLINT arg1 ;
12471 PLINT arg2 ;
12472 void *arg3 = (void *) 0 ;
12473 int val1 ;
12474 int ecode1 = 0 ;
12475 int val2 ;
12476 int ecode2 = 0 ;
12477 PyObject *swig_obj[3] ;
12478
12479 (void)self;
12480 if (!SWIG_Python_UnpackTuple(args, "plsmem", 3, 3, swig_obj)) SWIG_fail;
12481 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12482 if (!SWIG_IsOK(ecode1)) {
12483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12484 }
12485 arg1 = (PLINT)(val1);
12486 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12487 if (!SWIG_IsOK(ecode2)) {
12488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12489 }
12490 arg2 = (PLINT)(val2);
12491 {
12492 int res; void *buf = 0;
12493#ifndef Py_LIMITED_API
12494 Py_buffer view;
12495 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12496#else
12497#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12498#pragma GCC diagnostic push
12499#pragma GCC diagnostic ignored "-Wdeprecated"
12500#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12501#elif defined(_MSC_VER)
12502#pragma warning(push)
12503#pragma warning(disable: 4996)
12504#endif
12505 Py_ssize_t size;
12506 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12507#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12508#pragma GCC diagnostic pop
12509#elif defined(_MSC_VER)
12510#pragma warning(pop)
12511#endif
12512#endif
12513 if (res < 0) {
12514 PyErr_Clear();
12515 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem)""'");
12516 }
12517#ifndef Py_LIMITED_API
12518 buf = view.buf;
12519 PyBuffer_Release(&view);
12520#endif
12521 arg3 = (void *) buf;
12522 }
12523 plsmem(arg1,arg2,arg3);
12524 resultobj = SWIG_Py_Void();
12525 return resultobj;
12526fail:
12527 return NULL;
12528}
12529
12530
12531SWIGINTERN PyObject *_wrap_plsmema(PyObject *self, PyObject *args) {
12532 PyObject *resultobj = 0;
12533 PLINT arg1 ;
12534 PLINT arg2 ;
12535 void *arg3 = (void *) 0 ;
12536 int val1 ;
12537 int ecode1 = 0 ;
12538 int val2 ;
12539 int ecode2 = 0 ;
12540 PyObject *swig_obj[3] ;
12541
12542 (void)self;
12543 if (!SWIG_Python_UnpackTuple(args, "plsmema", 3, 3, swig_obj)) SWIG_fail;
12544 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12545 if (!SWIG_IsOK(ecode1)) {
12546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12547 }
12548 arg1 = (PLINT)(val1);
12549 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12550 if (!SWIG_IsOK(ecode2)) {
12551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12552 }
12553 arg2 = (PLINT)(val2);
12554 {
12555 int res; void *buf = 0;
12556#ifndef Py_LIMITED_API
12557 Py_buffer view;
12558 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12559#else
12560#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12561#pragma GCC diagnostic push
12562#pragma GCC diagnostic ignored "-Wdeprecated"
12563#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12564#elif defined(_MSC_VER)
12565#pragma warning(push)
12566#pragma warning(disable: 4996)
12567#endif
12568 Py_ssize_t size;
12569 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12570#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12571#pragma GCC diagnostic pop
12572#elif defined(_MSC_VER)
12573#pragma warning(pop)
12574#endif
12575#endif
12576 if (res < 0) {
12577 PyErr_Clear();
12578 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem)""'");
12579 }
12580#ifndef Py_LIMITED_API
12581 buf = view.buf;
12582 PyBuffer_Release(&view);
12583#endif
12584 arg3 = (void *) buf;
12585 }
12586 plsmema(arg1,arg2,arg3);
12587 resultobj = SWIG_Py_Void();
12588 return resultobj;
12589fail:
12590 return NULL;
12591}
12592
12593
12594SWIGINTERN PyObject *_wrap_plsmin(PyObject *self, PyObject *args) {
12595 PyObject *resultobj = 0;
12596 PLFLT arg1 ;
12597 PLFLT arg2 ;
12598 double val1 ;
12599 int ecode1 = 0 ;
12600 double val2 ;
12601 int ecode2 = 0 ;
12602 PyObject *swig_obj[2] ;
12603
12604 (void)self;
12605 if (!SWIG_Python_UnpackTuple(args, "plsmin", 2, 2, swig_obj)) SWIG_fail;
12606 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12607 if (!SWIG_IsOK(ecode1)) {
12608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12609 }
12610 arg1 = (PLFLT)(val1);
12611 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12612 if (!SWIG_IsOK(ecode2)) {
12613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12614 }
12615 arg2 = (PLFLT)(val2);
12616 plsmin(arg1,arg2);
12617 resultobj = SWIG_Py_Void();
12618 return resultobj;
12619fail:
12620 return NULL;
12621}
12622
12623
12624SWIGINTERN PyObject *_wrap_plsori(PyObject *self, PyObject *args) {
12625 PyObject *resultobj = 0;
12626 PLINT arg1 ;
12627 int val1 ;
12628 int ecode1 = 0 ;
12629 PyObject *swig_obj[1] ;
12630
12631 (void)self;
12632 if (!args) SWIG_fail;
12633 swig_obj[0] = args;
12634 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12635 if (!SWIG_IsOK(ecode1)) {
12636 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12637 }
12638 arg1 = (PLINT)(val1);
12639 plsori(arg1);
12640 resultobj = SWIG_Py_Void();
12641 return resultobj;
12642fail:
12643 return NULL;
12644}
12645
12646
12647SWIGINTERN PyObject *_wrap_plspage(PyObject *self, PyObject *args) {
12648 PyObject *resultobj = 0;
12649 PLFLT arg1 ;
12650 PLFLT arg2 ;
12651 PLINT arg3 ;
12652 PLINT arg4 ;
12653 PLINT arg5 ;
12654 PLINT arg6 ;
12655 double val1 ;
12656 int ecode1 = 0 ;
12657 double val2 ;
12658 int ecode2 = 0 ;
12659 int val3 ;
12660 int ecode3 = 0 ;
12661 int val4 ;
12662 int ecode4 = 0 ;
12663 int val5 ;
12664 int ecode5 = 0 ;
12665 int val6 ;
12666 int ecode6 = 0 ;
12667 PyObject *swig_obj[6] ;
12668
12669 (void)self;
12670 if (!SWIG_Python_UnpackTuple(args, "plspage", 6, 6, swig_obj)) SWIG_fail;
12671 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12672 if (!SWIG_IsOK(ecode1)) {
12673 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12674 }
12675 arg1 = (PLFLT)(val1);
12676 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12677 if (!SWIG_IsOK(ecode2)) {
12678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12679 }
12680 arg2 = (PLFLT)(val2);
12681 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12682 if (!SWIG_IsOK(ecode3)) {
12683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12684 }
12685 arg3 = (PLINT)(val3);
12686 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
12687 if (!SWIG_IsOK(ecode4)) {
12688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12689 }
12690 arg4 = (PLINT)(val4);
12691 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
12692 if (!SWIG_IsOK(ecode5)) {
12693 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12694 }
12695 arg5 = (PLINT)(val5);
12696 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
12697 if (!SWIG_IsOK(ecode6)) {
12698 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12699 }
12700 arg6 = (PLINT)(val6);
12701 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12702 resultobj = SWIG_Py_Void();
12703 return resultobj;
12704fail:
12705 return NULL;
12706}
12707
12708
12709SWIGINTERN PyObject *_wrap_plspal0(PyObject *self, PyObject *args) {
12710 PyObject *resultobj = 0;
12711 char *arg1 = (char *) 0 ;
12712 int res1 ;
12713 char *buf1 = 0 ;
12714 int alloc1 = 0 ;
12715 PyObject *swig_obj[1] ;
12716
12717 (void)self;
12718 if (!args) SWIG_fail;
12719 swig_obj[0] = args;
12720 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12721 if (!SWIG_IsOK(res1)) {
12722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12723 }
12724 arg1 = (char *)(buf1);
12725 plspal0((char const *)arg1);
12726 resultobj = SWIG_Py_Void();
12727 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12728 return resultobj;
12729fail:
12730 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12731 return NULL;
12732}
12733
12734
12735SWIGINTERN PyObject *_wrap_plspal1(PyObject *self, PyObject *args) {
12736 PyObject *resultobj = 0;
12737 char *arg1 = (char *) 0 ;
12738 PLBOOL arg2 ;
12739 int res1 ;
12740 char *buf1 = 0 ;
12741 int alloc1 = 0 ;
12742 int val2 ;
12743 int ecode2 = 0 ;
12744 PyObject *swig_obj[2] ;
12745
12746 (void)self;
12747 if (!SWIG_Python_UnpackTuple(args, "plspal1", 2, 2, swig_obj)) SWIG_fail;
12748 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12749 if (!SWIG_IsOK(res1)) {
12750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12751 }
12752 arg1 = (char *)(buf1);
12753 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12754 if (!SWIG_IsOK(ecode2)) {
12755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12756 }
12757 arg2 = (PLBOOL)(val2);
12758 plspal1((char const *)arg1,arg2);
12759 resultobj = SWIG_Py_Void();
12760 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12761 return resultobj;
12762fail:
12763 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12764 return NULL;
12765}
12766
12767
12768SWIGINTERN PyObject *_wrap_plspause(PyObject *self, PyObject *args) {
12769 PyObject *resultobj = 0;
12770 PLBOOL arg1 ;
12771 int val1 ;
12772 int ecode1 = 0 ;
12773 PyObject *swig_obj[1] ;
12774
12775 (void)self;
12776 if (!args) SWIG_fail;
12777 swig_obj[0] = args;
12778 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12779 if (!SWIG_IsOK(ecode1)) {
12780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12781 }
12782 arg1 = (PLBOOL)(val1);
12783 plspause(arg1);
12784 resultobj = SWIG_Py_Void();
12785 return resultobj;
12786fail:
12787 return NULL;
12788}
12789
12790
12791SWIGINTERN PyObject *_wrap_plsstrm(PyObject *self, PyObject *args) {
12792 PyObject *resultobj = 0;
12793 PLINT arg1 ;
12794 int val1 ;
12795 int ecode1 = 0 ;
12796 PyObject *swig_obj[1] ;
12797
12798 (void)self;
12799 if (!args) SWIG_fail;
12800 swig_obj[0] = args;
12801 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12802 if (!SWIG_IsOK(ecode1)) {
12803 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12804 }
12805 arg1 = (PLINT)(val1);
12806 plsstrm(arg1);
12807 resultobj = SWIG_Py_Void();
12808 return resultobj;
12809fail:
12810 return NULL;
12811}
12812
12813
12814SWIGINTERN PyObject *_wrap_plssub(PyObject *self, PyObject *args) {
12815 PyObject *resultobj = 0;
12816 PLINT arg1 ;
12817 PLINT arg2 ;
12818 int val1 ;
12819 int ecode1 = 0 ;
12820 int val2 ;
12821 int ecode2 = 0 ;
12822 PyObject *swig_obj[2] ;
12823
12824 (void)self;
12825 if (!SWIG_Python_UnpackTuple(args, "plssub", 2, 2, swig_obj)) SWIG_fail;
12826 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12827 if (!SWIG_IsOK(ecode1)) {
12828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12829 }
12830 arg1 = (PLINT)(val1);
12831 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12832 if (!SWIG_IsOK(ecode2)) {
12833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12834 }
12835 arg2 = (PLINT)(val2);
12836 plssub(arg1,arg2);
12837 resultobj = SWIG_Py_Void();
12838 return resultobj;
12839fail:
12840 return NULL;
12841}
12842
12843
12844SWIGINTERN PyObject *_wrap_plssym(PyObject *self, PyObject *args) {
12845 PyObject *resultobj = 0;
12846 PLFLT arg1 ;
12847 PLFLT arg2 ;
12848 double val1 ;
12849 int ecode1 = 0 ;
12850 double val2 ;
12851 int ecode2 = 0 ;
12852 PyObject *swig_obj[2] ;
12853
12854 (void)self;
12855 if (!SWIG_Python_UnpackTuple(args, "plssym", 2, 2, swig_obj)) SWIG_fail;
12856 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12857 if (!SWIG_IsOK(ecode1)) {
12858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12859 }
12860 arg1 = (PLFLT)(val1);
12861 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12862 if (!SWIG_IsOK(ecode2)) {
12863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12864 }
12865 arg2 = (PLFLT)(val2);
12866 plssym(arg1,arg2);
12867 resultobj = SWIG_Py_Void();
12868 return resultobj;
12869fail:
12870 return NULL;
12871}
12872
12873
12874SWIGINTERN PyObject *_wrap_plstar(PyObject *self, PyObject *args) {
12875 PyObject *resultobj = 0;
12876 PLINT arg1 ;
12877 PLINT arg2 ;
12878 int val1 ;
12879 int ecode1 = 0 ;
12880 int val2 ;
12881 int ecode2 = 0 ;
12882 PyObject *swig_obj[2] ;
12883
12884 (void)self;
12885 if (!SWIG_Python_UnpackTuple(args, "plstar", 2, 2, swig_obj)) SWIG_fail;
12886 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12887 if (!SWIG_IsOK(ecode1)) {
12888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12889 }
12890 arg1 = (PLINT)(val1);
12891 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12892 if (!SWIG_IsOK(ecode2)) {
12893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12894 }
12895 arg2 = (PLINT)(val2);
12896 plstar(arg1,arg2);
12897 resultobj = SWIG_Py_Void();
12898 return resultobj;
12899fail:
12900 return NULL;
12901}
12902
12903
12904SWIGINTERN PyObject *_wrap_plstart(PyObject *self, PyObject *args) {
12905 PyObject *resultobj = 0;
12906 char *arg1 = (char *) 0 ;
12907 PLINT arg2 ;
12908 PLINT arg3 ;
12909 int res1 ;
12910 char *buf1 = 0 ;
12911 int alloc1 = 0 ;
12912 int val2 ;
12913 int ecode2 = 0 ;
12914 int val3 ;
12915 int ecode3 = 0 ;
12916 PyObject *swig_obj[3] ;
12917
12918 (void)self;
12919 if (!SWIG_Python_UnpackTuple(args, "plstart", 3, 3, swig_obj)) SWIG_fail;
12920 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12921 if (!SWIG_IsOK(res1)) {
12922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12923 }
12924 arg1 = (char *)(buf1);
12925 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12926 if (!SWIG_IsOK(ecode2)) {
12927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12928 }
12929 arg2 = (PLINT)(val2);
12930 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12931 if (!SWIG_IsOK(ecode3)) {
12932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12933 }
12934 arg3 = (PLINT)(val3);
12935 plstart((char const *)arg1,arg2,arg3);
12936 resultobj = SWIG_Py_Void();
12937 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12938 return resultobj;
12939fail:
12940 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12941 return NULL;
12942}
12943
12944
12945SWIGINTERN PyObject *_wrap_plstransform(PyObject *self, PyObject *args) {
12946 PyObject *resultobj = 0;
12947 ct_func arg1 = (ct_func) 0 ;
12948 PLPointer arg2 = (PLPointer) 0 ;
12949 int res2 ;
12950 PyObject *swig_obj[2] ;
12951
12952 {
12953 python_ct = 0;
12954 arg1 = NULL;
12955 }
12956 (void)self;
12957 if (!SWIG_Python_UnpackTuple(args, "plstransform", 0, 2, swig_obj)) SWIG_fail;
12958 if (swig_obj[0]) {
12959 {
12960 if ( python_ct )
12961 cleanup_ct();
12962 // it must be a callable or none
12963 if ( swig_obj[0] == Py_None )
12964 {
12965 arg1 = NULL;
12966 }
12967 else
12968 {
12969 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12970 {
12971 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12972 return NULL;
12973 }
12974 arg1 = marshal_ct( swig_obj[0] );
12975 }
12976 }
12977 }
12978 if (swig_obj[1]) {
12979 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12980 if (!SWIG_IsOK(res2)) {
12981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12982 }
12983 }
12984 plstransform(arg1,arg2);
12985 resultobj = SWIG_Py_Void();
12986 return resultobj;
12987fail:
12988 return NULL;
12989}
12990
12991
12992SWIGINTERN PyObject *_wrap_plstring(PyObject *self, PyObject *args) {
12993 PyObject *resultobj = 0;
12994 PLINT arg1 ;
12995 PLFLT *arg2 = (PLFLT *) 0 ;
12996 PLFLT *arg3 = (PLFLT *) 0 ;
12997 char *arg4 = (char *) 0 ;
12998 PyArrayObject *tmp1 = NULL ;
12999 PyArrayObject *tmp3 = NULL ;
13000 int res4 ;
13001 char *buf4 = 0 ;
13002 int alloc4 = 0 ;
13003 PyObject *swig_obj[3] ;
13004
13005 (void)self;
13006 if (!SWIG_Python_UnpackTuple(args, "plstring", 3, 3, swig_obj)) SWIG_fail;
13007 {
13008 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13009 if ( tmp1 == NULL )
13010 return NULL;
13011 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13012 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13013 }
13014 {
13015 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13016 if ( tmp3 == NULL )
13017 return NULL;
13018 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13019 {
13020 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13021 return NULL;
13022 }
13023 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13024 }
13025 res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
13026 if (!SWIG_IsOK(res4)) {
13027 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
13028 }
13029 arg4 = (char *)(buf4);
13030 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
13031 resultobj = SWIG_Py_Void();
13032 {
13033 Py_CLEAR( tmp1 );
13034 }
13035 {
13036 Py_CLEAR( tmp3 );
13037 }
13038 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13039 return resultobj;
13040fail:
13041 {
13042 Py_CLEAR( tmp1 );
13043 }
13044 {
13045 Py_CLEAR( tmp3 );
13046 }
13047 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13048 return NULL;
13049}
13050
13051
13052SWIGINTERN PyObject *_wrap_plstring3(PyObject *self, PyObject *args) {
13053 PyObject *resultobj = 0;
13054 PLINT arg1 ;
13055 PLFLT *arg2 = (PLFLT *) 0 ;
13056 PLFLT *arg3 = (PLFLT *) 0 ;
13057 PLFLT *arg4 = (PLFLT *) 0 ;
13058 char *arg5 = (char *) 0 ;
13059 PyArrayObject *tmp1 = NULL ;
13060 PyArrayObject *tmp3 = NULL ;
13061 PyArrayObject *tmp4 = NULL ;
13062 int res5 ;
13063 char *buf5 = 0 ;
13064 int alloc5 = 0 ;
13065 PyObject *swig_obj[4] ;
13066
13067 (void)self;
13068 if (!SWIG_Python_UnpackTuple(args, "plstring3", 4, 4, swig_obj)) SWIG_fail;
13069 {
13070 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13071 if ( tmp1 == NULL )
13072 return NULL;
13073 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13074 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13075 }
13076 {
13077 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13078 if ( tmp3 == NULL )
13079 return NULL;
13080 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13081 {
13082 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13083 return NULL;
13084 }
13085 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13086 }
13087 {
13088 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
13089 if ( tmp4 == NULL )
13090 return NULL;
13091 if ( PyArray_DIMS( tmp4 )[0] != Alen )
13092 {
13093 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13094 return NULL;
13095 }
13096 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
13097 }
13098 res5 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf5, NULL, &alloc5);
13099 if (!SWIG_IsOK(res5)) {
13100 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
13101 }
13102 arg5 = (char *)(buf5);
13103 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
13104 resultobj = SWIG_Py_Void();
13105 {
13106 Py_CLEAR( tmp1 );
13107 }
13108 {
13109 Py_CLEAR( tmp3 );
13110 }
13111 {
13112 Py_CLEAR( tmp4 );
13113 }
13114 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13115 return resultobj;
13116fail:
13117 {
13118 Py_CLEAR( tmp1 );
13119 }
13120 {
13121 Py_CLEAR( tmp3 );
13122 }
13123 {
13124 Py_CLEAR( tmp4 );
13125 }
13126 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13127 return NULL;
13128}
13129
13130
13131SWIGINTERN PyObject *_wrap_plstripa(PyObject *self, PyObject *args) {
13132 PyObject *resultobj = 0;
13133 PLINT arg1 ;
13134 PLINT arg2 ;
13135 PLFLT arg3 ;
13136 PLFLT arg4 ;
13137 int val1 ;
13138 int ecode1 = 0 ;
13139 int val2 ;
13140 int ecode2 = 0 ;
13141 double val3 ;
13142 int ecode3 = 0 ;
13143 double val4 ;
13144 int ecode4 = 0 ;
13145 PyObject *swig_obj[4] ;
13146
13147 (void)self;
13148 if (!SWIG_Python_UnpackTuple(args, "plstripa", 4, 4, swig_obj)) SWIG_fail;
13149 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13150 if (!SWIG_IsOK(ecode1)) {
13151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
13152 }
13153 arg1 = (PLINT)(val1);
13154 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13155 if (!SWIG_IsOK(ecode2)) {
13156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
13157 }
13158 arg2 = (PLINT)(val2);
13159 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13160 if (!SWIG_IsOK(ecode3)) {
13161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
13162 }
13163 arg3 = (PLFLT)(val3);
13164 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13165 if (!SWIG_IsOK(ecode4)) {
13166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
13167 }
13168 arg4 = (PLFLT)(val4);
13169 plstripa(arg1,arg2,arg3,arg4);
13170 resultobj = SWIG_Py_Void();
13171 return resultobj;
13172fail:
13173 return NULL;
13174}
13175
13176
13177SWIGINTERN PyObject *_wrap_plstripc(PyObject *self, PyObject *args) {
13178 PyObject *resultobj = 0;
13179 PLINT *arg1 = (PLINT *) 0 ;
13180 char *arg2 = (char *) 0 ;
13181 char *arg3 = (char *) 0 ;
13182 PLFLT arg4 ;
13183 PLFLT arg5 ;
13184 PLFLT arg6 ;
13185 PLFLT arg7 ;
13186 PLFLT arg8 ;
13187 PLFLT arg9 ;
13188 PLFLT arg10 ;
13189 PLBOOL arg11 ;
13190 PLBOOL arg12 ;
13191 PLINT arg13 ;
13192 PLINT arg14 ;
13193 PLINT *arg15 = (PLINT *) 0 ;
13194 PLINT *arg16 = (PLINT *) 0 ;
13195 char **arg17 = (char **) (char **)0 ;
13196 char *arg18 = (char *) 0 ;
13197 char *arg19 = (char *) 0 ;
13198 char *arg20 = (char *) 0 ;
13199 PLINT temp1 ;
13200 int res1 = SWIG_TMPOBJ ;
13201 int res2 ;
13202 char *buf2 = 0 ;
13203 int alloc2 = 0 ;
13204 int res3 ;
13205 char *buf3 = 0 ;
13206 int alloc3 = 0 ;
13207 double val4 ;
13208 int ecode4 = 0 ;
13209 double val5 ;
13210 int ecode5 = 0 ;
13211 double val6 ;
13212 int ecode6 = 0 ;
13213 double val7 ;
13214 int ecode7 = 0 ;
13215 double val8 ;
13216 int ecode8 = 0 ;
13217 double val9 ;
13218 int ecode9 = 0 ;
13219 double val10 ;
13220 int ecode10 = 0 ;
13221 int val11 ;
13222 int ecode11 = 0 ;
13223 int val12 ;
13224 int ecode12 = 0 ;
13225 int val13 ;
13226 int ecode13 = 0 ;
13227 int val14 ;
13228 int ecode14 = 0 ;
13229 PyArrayObject *tmp15 = NULL ;
13230 PyArrayObject *tmp16 = NULL ;
13231 char **tmp17 = NULL ;
13232 int res18 ;
13233 char *buf18 = 0 ;
13234 int alloc18 = 0 ;
13235 int res19 ;
13236 char *buf19 = 0 ;
13237 int alloc19 = 0 ;
13238 int res20 ;
13239 char *buf20 = 0 ;
13240 int alloc20 = 0 ;
13241 PyObject *swig_obj[19] ;
13242
13243 arg1 = &temp1;
13244 (void)self;
13245 if (!SWIG_Python_UnpackTuple(args, "plstripc", 19, 19, swig_obj)) SWIG_fail;
13246 res2 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf2, NULL, &alloc2);
13247 if (!SWIG_IsOK(res2)) {
13248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13249 }
13250 arg2 = (char *)(buf2);
13251 res3 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf3, NULL, &alloc3);
13252 if (!SWIG_IsOK(res3)) {
13253 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13254 }
13255 arg3 = (char *)(buf3);
13256 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
13257 if (!SWIG_IsOK(ecode4)) {
13258 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13259 }
13260 arg4 = (PLFLT)(val4);
13261 ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
13262 if (!SWIG_IsOK(ecode5)) {
13263 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13264 }
13265 arg5 = (PLFLT)(val5);
13266 ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
13267 if (!SWIG_IsOK(ecode6)) {
13268 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13269 }
13270 arg6 = (PLFLT)(val6);
13271 ecode7 = SWIG_AsVal_double(swig_obj[5], &val7);
13272 if (!SWIG_IsOK(ecode7)) {
13273 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13274 }
13275 arg7 = (PLFLT)(val7);
13276 ecode8 = SWIG_AsVal_double(swig_obj[6], &val8);
13277 if (!SWIG_IsOK(ecode8)) {
13278 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13279 }
13280 arg8 = (PLFLT)(val8);
13281 ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
13282 if (!SWIG_IsOK(ecode9)) {
13283 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13284 }
13285 arg9 = (PLFLT)(val9);
13286 ecode10 = SWIG_AsVal_double(swig_obj[8], &val10);
13287 if (!SWIG_IsOK(ecode10)) {
13288 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13289 }
13290 arg10 = (PLFLT)(val10);
13291 ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
13292 if (!SWIG_IsOK(ecode11)) {
13293 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13294 }
13295 arg11 = (PLBOOL)(val11);
13296 ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
13297 if (!SWIG_IsOK(ecode12)) {
13298 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13299 }
13300 arg12 = (PLBOOL)(val12);
13301 ecode13 = SWIG_AsVal_int(swig_obj[11], &val13);
13302 if (!SWIG_IsOK(ecode13)) {
13303 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13304 }
13305 arg13 = (PLINT)(val13);
13306 ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
13307 if (!SWIG_IsOK(ecode14)) {
13308 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13309 }
13310 arg14 = (PLINT)(val14);
13311 {
13312 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
13313 if ( tmp15 == NULL )
13314 return NULL;
13315 Alen = PyArray_DIMS( tmp15 )[0];
13316 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13317 }
13318 {
13319 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[14], NPY_PLINT, 1, 1 );
13320 if ( tmp16 == NULL )
13321 return NULL;
13322 if ( PyArray_DIMS( tmp16 )[0] != Alen )
13323 {
13324 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13325 return NULL;
13326 }
13327 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13328 }
13329 {
13330 int i;
13331 PyObject *elt, *unicode_string;
13332
13333 if ( !PySequence_Check( swig_obj[15] ) || PySequence_Size( swig_obj[15] ) != 4 )
13334 {
13335 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13336 return NULL;
13337 }
13338 if ( Alen != 4 )
13339 {
13340 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13341 return NULL;
13342 }
13343 tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13344 if ( tmp17 == NULL )
13345 return NULL;
13346 arg17 = tmp17;
13347 for ( i = 0; i < 4; i++ )
13348 {
13349 arg17[i] = NULL;
13350 elt = PySequence_Fast_GET_ITEM( swig_obj[15], i );
13351 if ( PyString_Check( elt ) )
13352 {
13353 arg17[i] = PyString_AsString( elt );
13354 }
13355 else if ( PyUnicode_Check( elt ) )
13356 {
13357 unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
13358 arg17[i] = PyBytes_AS_STRING( unicode_string );
13359 }
13360 if ( arg17[i] == NULL )
13361 {
13362 free( tmp17 );
13363 return NULL;
13364 }
13365 }
13366 }
13367 res18 = SWIG_AsCharPtrAndSize(swig_obj[16], &buf18, NULL, &alloc18);
13368 if (!SWIG_IsOK(res18)) {
13369 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13370 }
13371 arg18 = (char *)(buf18);
13372 res19 = SWIG_AsCharPtrAndSize(swig_obj[17], &buf19, NULL, &alloc19);
13373 if (!SWIG_IsOK(res19)) {
13374 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13375 }
13376 arg19 = (char *)(buf19);
13377 res20 = SWIG_AsCharPtrAndSize(swig_obj[18], &buf20, NULL, &alloc20);
13378 if (!SWIG_IsOK(res20)) {
13379 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13380 }
13381 arg20 = (char *)(buf20);
13382 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);
13383 resultobj = SWIG_Py_Void();
13384 if (SWIG_IsTmpObj(res1)) {
13385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13386 } else {
13387 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13389 }
13390 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13391 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13392 {
13393 Py_CLEAR( tmp15 );
13394 }
13395 {
13396 Py_CLEAR( tmp16 );
13397 }
13398 {
13399 free( tmp17 );
13400 }
13401 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13402 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13403 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13404 return resultobj;
13405fail:
13406 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13407 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13408 {
13409 Py_CLEAR( tmp15 );
13410 }
13411 {
13412 Py_CLEAR( tmp16 );
13413 }
13414 {
13415 free( tmp17 );
13416 }
13417 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13418 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13419 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13420 return NULL;
13421}
13422
13423
13424SWIGINTERN PyObject *_wrap_plstripd(PyObject *self, PyObject *args) {
13425 PyObject *resultobj = 0;
13426 PLINT arg1 ;
13427 int val1 ;
13428 int ecode1 = 0 ;
13429 PyObject *swig_obj[1] ;
13430
13431 (void)self;
13432 if (!args) SWIG_fail;
13433 swig_obj[0] = args;
13434 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13435 if (!SWIG_IsOK(ecode1)) {
13436 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13437 }
13438 arg1 = (PLINT)(val1);
13439 plstripd(arg1);
13440 resultobj = SWIG_Py_Void();
13441 return resultobj;
13442fail:
13443 return NULL;
13444}
13445
13446
13447SWIGINTERN PyObject *_wrap_plstyl(PyObject *self, PyObject *args) {
13448 PyObject *resultobj = 0;
13449 PLINT arg1 ;
13450 PLINT *arg2 = (PLINT *) 0 ;
13451 PLINT *arg3 = (PLINT *) 0 ;
13452 PyArrayObject *tmp1 = NULL ;
13453 PyArrayObject *tmp3 = NULL ;
13454 PyObject *swig_obj[2] ;
13455
13456 (void)self;
13457 if (!SWIG_Python_UnpackTuple(args, "plstyl", 2, 2, swig_obj)) SWIG_fail;
13458 {
13459 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
13460 if ( tmp1 == NULL )
13461 return NULL;
13462 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13463 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13464 }
13465 {
13466 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
13467 if ( tmp3 == NULL )
13468 return NULL;
13469 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13470 {
13471 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13472 return NULL;
13473 }
13474 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13475 }
13476 plstyl(arg1,(int const *)arg2,(int const *)arg3);
13477 resultobj = SWIG_Py_Void();
13478 {
13479 Py_CLEAR( tmp1 );
13480 }
13481 {
13482 Py_CLEAR( tmp3 );
13483 }
13484 return resultobj;
13485fail:
13486 {
13487 Py_CLEAR( tmp1 );
13488 }
13489 {
13490 Py_CLEAR( tmp3 );
13491 }
13492 return NULL;
13493}
13494
13495
13496SWIGINTERN PyObject *_wrap_plsvect(PyObject *self, PyObject *args) {
13497 PyObject *resultobj = 0;
13498 PLFLT *arg1 = (PLFLT *) 0 ;
13499 PLFLT *arg2 = (PLFLT *) 0 ;
13500 PLINT arg3 ;
13501 PLBOOL arg4 ;
13502 PyArrayObject *tmp1 = NULL ;
13503 PyArrayObject *tmp2 = NULL ;
13504 int val4 ;
13505 int ecode4 = 0 ;
13506 PyObject *swig_obj[3] ;
13507
13508 (void)self;
13509 if (!SWIG_Python_UnpackTuple(args, "plsvect", 3, 3, swig_obj)) SWIG_fail;
13510 {
13511 if ( swig_obj[0] != Py_None )
13512 {
13513 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13514 if ( tmp1 == NULL )
13515 return NULL;
13516 Alen = PyArray_DIMS( tmp1 )[0];
13517 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13518 }
13519 else
13520 {
13521 arg1 = NULL;
13522 Alen = 0;
13523 }
13524 }
13525 {
13526 if ( swig_obj[1] != Py_None )
13527 {
13528 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13529 if ( tmp2 == NULL )
13530 return NULL;
13531 if ( PyArray_DIMS( tmp2 )[0] != Alen )
13532 {
13533 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13534 return NULL;
13535 }
13536 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13537 arg3 = PyArray_DIMS( tmp2 )[0];
13538 }
13539 else
13540 {
13541 arg2 = NULL;
13542 arg3 = 0;
13543 }
13544 }
13545 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13546 if (!SWIG_IsOK(ecode4)) {
13547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13548 }
13549 arg4 = (PLBOOL)(val4);
13550 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13551 resultobj = SWIG_Py_Void();
13552 {
13553 Py_CLEAR( tmp1 );
13554 }
13555 {
13556 Py_CLEAR( tmp2 );
13557 }
13558 return resultobj;
13559fail:
13560 {
13561 Py_CLEAR( tmp1 );
13562 }
13563 {
13564 Py_CLEAR( tmp2 );
13565 }
13566 return NULL;
13567}
13568
13569
13570SWIGINTERN PyObject *_wrap_plsvpa(PyObject *self, PyObject *args) {
13571 PyObject *resultobj = 0;
13572 PLFLT arg1 ;
13573 PLFLT arg2 ;
13574 PLFLT arg3 ;
13575 PLFLT arg4 ;
13576 double val1 ;
13577 int ecode1 = 0 ;
13578 double val2 ;
13579 int ecode2 = 0 ;
13580 double val3 ;
13581 int ecode3 = 0 ;
13582 double val4 ;
13583 int ecode4 = 0 ;
13584 PyObject *swig_obj[4] ;
13585
13586 (void)self;
13587 if (!SWIG_Python_UnpackTuple(args, "plsvpa", 4, 4, swig_obj)) SWIG_fail;
13588 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13589 if (!SWIG_IsOK(ecode1)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13591 }
13592 arg1 = (PLFLT)(val1);
13593 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13594 if (!SWIG_IsOK(ecode2)) {
13595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13596 }
13597 arg2 = (PLFLT)(val2);
13598 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13599 if (!SWIG_IsOK(ecode3)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13601 }
13602 arg3 = (PLFLT)(val3);
13603 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13604 if (!SWIG_IsOK(ecode4)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13606 }
13607 arg4 = (PLFLT)(val4);
13608 plsvpa(arg1,arg2,arg3,arg4);
13609 resultobj = SWIG_Py_Void();
13610 return resultobj;
13611fail:
13612 return NULL;
13613}
13614
13615
13616SWIGINTERN PyObject *_wrap_plsxax(PyObject *self, PyObject *args) {
13617 PyObject *resultobj = 0;
13618 PLINT arg1 ;
13619 PLINT arg2 ;
13620 int val1 ;
13621 int ecode1 = 0 ;
13622 int val2 ;
13623 int ecode2 = 0 ;
13624 PyObject *swig_obj[2] ;
13625
13626 (void)self;
13627 if (!SWIG_Python_UnpackTuple(args, "plsxax", 2, 2, swig_obj)) SWIG_fail;
13628 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13629 if (!SWIG_IsOK(ecode1)) {
13630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13631 }
13632 arg1 = (PLINT)(val1);
13633 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13634 if (!SWIG_IsOK(ecode2)) {
13635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13636 }
13637 arg2 = (PLINT)(val2);
13638 plsxax(arg1,arg2);
13639 resultobj = SWIG_Py_Void();
13640 return resultobj;
13641fail:
13642 return NULL;
13643}
13644
13645
13646SWIGINTERN PyObject *_wrap_plsyax(PyObject *self, PyObject *args) {
13647 PyObject *resultobj = 0;
13648 PLINT arg1 ;
13649 PLINT arg2 ;
13650 int val1 ;
13651 int ecode1 = 0 ;
13652 int val2 ;
13653 int ecode2 = 0 ;
13654 PyObject *swig_obj[2] ;
13655
13656 (void)self;
13657 if (!SWIG_Python_UnpackTuple(args, "plsyax", 2, 2, swig_obj)) SWIG_fail;
13658 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13659 if (!SWIG_IsOK(ecode1)) {
13660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13661 }
13662 arg1 = (PLINT)(val1);
13663 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13664 if (!SWIG_IsOK(ecode2)) {
13665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13666 }
13667 arg2 = (PLINT)(val2);
13668 plsyax(arg1,arg2);
13669 resultobj = SWIG_Py_Void();
13670 return resultobj;
13671fail:
13672 return NULL;
13673}
13674
13675
13676SWIGINTERN PyObject *_wrap_plsym(PyObject *self, PyObject *args) {
13677 PyObject *resultobj = 0;
13678 PLINT arg1 ;
13679 PLFLT *arg2 = (PLFLT *) 0 ;
13680 PLFLT *arg3 = (PLFLT *) 0 ;
13681 PLINT arg4 ;
13682 PyArrayObject *tmp1 = NULL ;
13683 PyArrayObject *tmp3 = NULL ;
13684 int val4 ;
13685 int ecode4 = 0 ;
13686 PyObject *swig_obj[3] ;
13687
13688 (void)self;
13689 if (!SWIG_Python_UnpackTuple(args, "plsym", 3, 3, swig_obj)) SWIG_fail;
13690 {
13691 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13692 if ( tmp1 == NULL )
13693 return NULL;
13694 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13695 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13696 }
13697 {
13698 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13699 if ( tmp3 == NULL )
13700 return NULL;
13701 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13702 {
13703 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13704 return NULL;
13705 }
13706 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13707 }
13708 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13709 if (!SWIG_IsOK(ecode4)) {
13710 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13711 }
13712 arg4 = (PLINT)(val4);
13713 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13714 resultobj = SWIG_Py_Void();
13715 {
13716 Py_CLEAR( tmp1 );
13717 }
13718 {
13719 Py_CLEAR( tmp3 );
13720 }
13721 return resultobj;
13722fail:
13723 {
13724 Py_CLEAR( tmp1 );
13725 }
13726 {
13727 Py_CLEAR( tmp3 );
13728 }
13729 return NULL;
13730}
13731
13732
13733SWIGINTERN PyObject *_wrap_plszax(PyObject *self, PyObject *args) {
13734 PyObject *resultobj = 0;
13735 PLINT arg1 ;
13736 PLINT arg2 ;
13737 int val1 ;
13738 int ecode1 = 0 ;
13739 int val2 ;
13740 int ecode2 = 0 ;
13741 PyObject *swig_obj[2] ;
13742
13743 (void)self;
13744 if (!SWIG_Python_UnpackTuple(args, "plszax", 2, 2, swig_obj)) SWIG_fail;
13745 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13746 if (!SWIG_IsOK(ecode1)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13748 }
13749 arg1 = (PLINT)(val1);
13750 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13751 if (!SWIG_IsOK(ecode2)) {
13752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13753 }
13754 arg2 = (PLINT)(val2);
13755 plszax(arg1,arg2);
13756 resultobj = SWIG_Py_Void();
13757 return resultobj;
13758fail:
13759 return NULL;
13760}
13761
13762
13763SWIGINTERN PyObject *_wrap_pltext(PyObject *self, PyObject *args) {
13764 PyObject *resultobj = 0;
13765
13766 (void)self;
13767 if (!SWIG_Python_UnpackTuple(args, "pltext", 0, 0, 0)) SWIG_fail;
13768 pltext();
13769 resultobj = SWIG_Py_Void();
13770 return resultobj;
13771fail:
13772 return NULL;
13773}
13774
13775
13776SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *self, PyObject *args) {
13777 PyObject *resultobj = 0;
13778 char *arg1 = (char *) 0 ;
13779 int res1 ;
13780 char *buf1 = 0 ;
13781 int alloc1 = 0 ;
13782 PyObject *swig_obj[1] ;
13783
13784 (void)self;
13785 if (!args) SWIG_fail;
13786 swig_obj[0] = args;
13787 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13788 if (!SWIG_IsOK(res1)) {
13789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13790 }
13791 arg1 = (char *)(buf1);
13792 pltimefmt((char const *)arg1);
13793 resultobj = SWIG_Py_Void();
13794 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13795 return resultobj;
13796fail:
13797 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13798 return NULL;
13799}
13800
13801
13802SWIGINTERN PyObject *_wrap_plvasp(PyObject *self, PyObject *args) {
13803 PyObject *resultobj = 0;
13804 PLFLT arg1 ;
13805 double val1 ;
13806 int ecode1 = 0 ;
13807 PyObject *swig_obj[1] ;
13808
13809 (void)self;
13810 if (!args) SWIG_fail;
13811 swig_obj[0] = args;
13812 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13813 if (!SWIG_IsOK(ecode1)) {
13814 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13815 }
13816 arg1 = (PLFLT)(val1);
13817 plvasp(arg1);
13818 resultobj = SWIG_Py_Void();
13819 return resultobj;
13820fail:
13821 return NULL;
13822}
13823
13824
13825SWIGINTERN PyObject *_wrap_plvect(PyObject *self, PyObject *args) {
13826 PyObject *resultobj = 0;
13827 PLFLT **arg1 = (PLFLT **) 0 ;
13828 PLFLT **arg2 = (PLFLT **) 0 ;
13829 PLINT arg3 ;
13830 PLINT arg4 ;
13831 PLFLT arg5 ;
13832 pltr_func arg6 = (pltr_func) 0 ;
13833 PLPointer arg7 = (PLPointer) 0 ;
13834 PyArrayObject *tmp1 = NULL ;
13835 PyArrayObject *tmp2 = NULL ;
13836 double val5 ;
13837 int ecode5 = 0 ;
13838 PyObject *swig_obj[5] ;
13839
13840 {
13841 python_pltr = 0;
13842 arg6 = NULL;
13843 }
13844 {
13845 arg7 = NULL;
13846 }
13847 (void)self;
13848 if (!SWIG_Python_UnpackTuple(args, "plvect", 3, 5, swig_obj)) SWIG_fail;
13849 {
13850 int i, size;
13851 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
13852 if ( tmp1 == NULL )
13853 return NULL;
13854 Xlen = PyArray_DIMS( tmp1 )[0];
13855 Ylen = PyArray_DIMS( tmp1 )[1];
13856 size = Ylen;
13857 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13858 for ( i = 0; i < Xlen; i++ )
13859 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13860 }
13861 {
13862 int i, size;
13863 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 2, 2 );
13864 if ( tmp2 == NULL )
13865 return NULL;
13866 if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13867 {
13868 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13869 return NULL;
13870 }
13871 arg3 = PyArray_DIMS( tmp2 )[0];
13872 arg4 = PyArray_DIMS( tmp2 )[1];
13873 size = arg4;
13874 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13875 for ( i = 0; i < arg3; i++ )
13876 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13877 }
13878 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
13879 if (!SWIG_IsOK(ecode5)) {
13880 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13881 }
13882 arg5 = (PLFLT)(val5);
13883 if (swig_obj[3]) {
13884 {
13885 // it must be a callable or None
13886 if ( swig_obj[3] == Py_None )
13887 {
13888 arg6 = NULL;
13889 }
13890 else
13891 {
13892 if ( !PyCallable_Check( (PyObject *) swig_obj[3] ) )
13893 {
13894 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13895 return NULL;
13896 }
13897 arg6 = marshal_pltr( swig_obj[3] );
13898 }
13899 }
13900 }
13901 if (swig_obj[4]) {
13902 {
13903 if ( swig_obj[4] == Py_None )
13904 arg7 = NULL;
13905 else
13906 {
13907 arg7 = marshal_PLPointer( swig_obj[4], 0 );
13908 }
13909 }
13910 }
13911 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13912 resultobj = SWIG_Py_Void();
13913 {
13914 Py_CLEAR( tmp1 );
13915 free( arg1 );
13916 }
13917 {
13918 Py_CLEAR( tmp2 );
13919 free( arg2 );
13920 }
13921 {
13922 cleanup_pltr();
13923 }
13924 {
13926 }
13927 return resultobj;
13928fail:
13929 {
13930 Py_CLEAR( tmp1 );
13931 free( arg1 );
13932 }
13933 {
13934 Py_CLEAR( tmp2 );
13935 free( arg2 );
13936 }
13937 {
13938 cleanup_pltr();
13939 }
13940 {
13942 }
13943 return NULL;
13944}
13945
13946
13947SWIGINTERN PyObject *_wrap_plvpas(PyObject *self, PyObject *args) {
13948 PyObject *resultobj = 0;
13949 PLFLT arg1 ;
13950 PLFLT arg2 ;
13951 PLFLT arg3 ;
13952 PLFLT arg4 ;
13953 PLFLT arg5 ;
13954 double val1 ;
13955 int ecode1 = 0 ;
13956 double val2 ;
13957 int ecode2 = 0 ;
13958 double val3 ;
13959 int ecode3 = 0 ;
13960 double val4 ;
13961 int ecode4 = 0 ;
13962 double val5 ;
13963 int ecode5 = 0 ;
13964 PyObject *swig_obj[5] ;
13965
13966 (void)self;
13967 if (!SWIG_Python_UnpackTuple(args, "plvpas", 5, 5, swig_obj)) SWIG_fail;
13968 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13969 if (!SWIG_IsOK(ecode1)) {
13970 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13971 }
13972 arg1 = (PLFLT)(val1);
13973 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13974 if (!SWIG_IsOK(ecode2)) {
13975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13976 }
13977 arg2 = (PLFLT)(val2);
13978 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13979 if (!SWIG_IsOK(ecode3)) {
13980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13981 }
13982 arg3 = (PLFLT)(val3);
13983 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13984 if (!SWIG_IsOK(ecode4)) {
13985 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13986 }
13987 arg4 = (PLFLT)(val4);
13988 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13989 if (!SWIG_IsOK(ecode5)) {
13990 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13991 }
13992 arg5 = (PLFLT)(val5);
13993 plvpas(arg1,arg2,arg3,arg4,arg5);
13994 resultobj = SWIG_Py_Void();
13995 return resultobj;
13996fail:
13997 return NULL;
13998}
13999
14000
14001SWIGINTERN PyObject *_wrap_plvpor(PyObject *self, PyObject *args) {
14002 PyObject *resultobj = 0;
14003 PLFLT arg1 ;
14004 PLFLT arg2 ;
14005 PLFLT arg3 ;
14006 PLFLT arg4 ;
14007 double val1 ;
14008 int ecode1 = 0 ;
14009 double val2 ;
14010 int ecode2 = 0 ;
14011 double val3 ;
14012 int ecode3 = 0 ;
14013 double val4 ;
14014 int ecode4 = 0 ;
14015 PyObject *swig_obj[4] ;
14016
14017 (void)self;
14018 if (!SWIG_Python_UnpackTuple(args, "plvpor", 4, 4, swig_obj)) SWIG_fail;
14019 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14020 if (!SWIG_IsOK(ecode1)) {
14021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
14022 }
14023 arg1 = (PLFLT)(val1);
14024 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14025 if (!SWIG_IsOK(ecode2)) {
14026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
14027 }
14028 arg2 = (PLFLT)(val2);
14029 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14030 if (!SWIG_IsOK(ecode3)) {
14031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
14032 }
14033 arg3 = (PLFLT)(val3);
14034 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14035 if (!SWIG_IsOK(ecode4)) {
14036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
14037 }
14038 arg4 = (PLFLT)(val4);
14039 plvpor(arg1,arg2,arg3,arg4);
14040 resultobj = SWIG_Py_Void();
14041 return resultobj;
14042fail:
14043 return NULL;
14044}
14045
14046
14047SWIGINTERN PyObject *_wrap_plvsta(PyObject *self, PyObject *args) {
14048 PyObject *resultobj = 0;
14049
14050 (void)self;
14051 if (!SWIG_Python_UnpackTuple(args, "plvsta", 0, 0, 0)) SWIG_fail;
14052 plvsta();
14053 resultobj = SWIG_Py_Void();
14054 return resultobj;
14055fail:
14056 return NULL;
14057}
14058
14059
14060SWIGINTERN PyObject *_wrap_plw3d(PyObject *self, PyObject *args) {
14061 PyObject *resultobj = 0;
14062 PLFLT arg1 ;
14063 PLFLT arg2 ;
14064 PLFLT arg3 ;
14065 PLFLT arg4 ;
14066 PLFLT arg5 ;
14067 PLFLT arg6 ;
14068 PLFLT arg7 ;
14069 PLFLT arg8 ;
14070 PLFLT arg9 ;
14071 PLFLT arg10 ;
14072 PLFLT arg11 ;
14073 double val1 ;
14074 int ecode1 = 0 ;
14075 double val2 ;
14076 int ecode2 = 0 ;
14077 double val3 ;
14078 int ecode3 = 0 ;
14079 double val4 ;
14080 int ecode4 = 0 ;
14081 double val5 ;
14082 int ecode5 = 0 ;
14083 double val6 ;
14084 int ecode6 = 0 ;
14085 double val7 ;
14086 int ecode7 = 0 ;
14087 double val8 ;
14088 int ecode8 = 0 ;
14089 double val9 ;
14090 int ecode9 = 0 ;
14091 double val10 ;
14092 int ecode10 = 0 ;
14093 double val11 ;
14094 int ecode11 = 0 ;
14095 PyObject *swig_obj[11] ;
14096
14097 (void)self;
14098 if (!SWIG_Python_UnpackTuple(args, "plw3d", 11, 11, swig_obj)) SWIG_fail;
14099 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14100 if (!SWIG_IsOK(ecode1)) {
14101 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
14102 }
14103 arg1 = (PLFLT)(val1);
14104 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14105 if (!SWIG_IsOK(ecode2)) {
14106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
14107 }
14108 arg2 = (PLFLT)(val2);
14109 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14110 if (!SWIG_IsOK(ecode3)) {
14111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
14112 }
14113 arg3 = (PLFLT)(val3);
14114 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14115 if (!SWIG_IsOK(ecode4)) {
14116 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
14117 }
14118 arg4 = (PLFLT)(val4);
14119 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14120 if (!SWIG_IsOK(ecode5)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
14122 }
14123 arg5 = (PLFLT)(val5);
14124 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14125 if (!SWIG_IsOK(ecode6)) {
14126 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
14127 }
14128 arg6 = (PLFLT)(val6);
14129 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14130 if (!SWIG_IsOK(ecode7)) {
14131 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
14132 }
14133 arg7 = (PLFLT)(val7);
14134 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14135 if (!SWIG_IsOK(ecode8)) {
14136 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
14137 }
14138 arg8 = (PLFLT)(val8);
14139 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14140 if (!SWIG_IsOK(ecode9)) {
14141 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
14142 }
14143 arg9 = (PLFLT)(val9);
14144 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14145 if (!SWIG_IsOK(ecode10)) {
14146 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
14147 }
14148 arg10 = (PLFLT)(val10);
14149 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
14150 if (!SWIG_IsOK(ecode11)) {
14151 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
14152 }
14153 arg11 = (PLFLT)(val11);
14154 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14155 resultobj = SWIG_Py_Void();
14156 return resultobj;
14157fail:
14158 return NULL;
14159}
14160
14161
14162SWIGINTERN PyObject *_wrap_plwidth(PyObject *self, PyObject *args) {
14163 PyObject *resultobj = 0;
14164 PLFLT arg1 ;
14165 double val1 ;
14166 int ecode1 = 0 ;
14167 PyObject *swig_obj[1] ;
14168
14169 (void)self;
14170 if (!args) SWIG_fail;
14171 swig_obj[0] = args;
14172 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14173 if (!SWIG_IsOK(ecode1)) {
14174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
14175 }
14176 arg1 = (PLFLT)(val1);
14177 plwidth(arg1);
14178 resultobj = SWIG_Py_Void();
14179 return resultobj;
14180fail:
14181 return NULL;
14182}
14183
14184
14185SWIGINTERN PyObject *_wrap_plwind(PyObject *self, PyObject *args) {
14186 PyObject *resultobj = 0;
14187 PLFLT arg1 ;
14188 PLFLT arg2 ;
14189 PLFLT arg3 ;
14190 PLFLT arg4 ;
14191 double val1 ;
14192 int ecode1 = 0 ;
14193 double val2 ;
14194 int ecode2 = 0 ;
14195 double val3 ;
14196 int ecode3 = 0 ;
14197 double val4 ;
14198 int ecode4 = 0 ;
14199 PyObject *swig_obj[4] ;
14200
14201 (void)self;
14202 if (!SWIG_Python_UnpackTuple(args, "plwind", 4, 4, swig_obj)) SWIG_fail;
14203 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14204 if (!SWIG_IsOK(ecode1)) {
14205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14206 }
14207 arg1 = (PLFLT)(val1);
14208 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14209 if (!SWIG_IsOK(ecode2)) {
14210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14211 }
14212 arg2 = (PLFLT)(val2);
14213 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14214 if (!SWIG_IsOK(ecode3)) {
14215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14216 }
14217 arg3 = (PLFLT)(val3);
14218 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14219 if (!SWIG_IsOK(ecode4)) {
14220 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14221 }
14222 arg4 = (PLFLT)(val4);
14223 plwind(arg1,arg2,arg3,arg4);
14224 resultobj = SWIG_Py_Void();
14225 return resultobj;
14226fail:
14227 return NULL;
14228}
14229
14230
14231SWIGINTERN PyObject *_wrap_plxormod(PyObject *self, PyObject *args) {
14232 PyObject *resultobj = 0;
14233 PLBOOL arg1 ;
14234 PLBOOL *arg2 = (PLBOOL *) 0 ;
14235 int val1 ;
14236 int ecode1 = 0 ;
14237 PLBOOL temp2 ;
14238 int res2 = SWIG_TMPOBJ ;
14239 PyObject *swig_obj[1] ;
14240
14241 arg2 = &temp2;
14242 (void)self;
14243 if (!args) SWIG_fail;
14244 swig_obj[0] = args;
14245 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
14246 if (!SWIG_IsOK(ecode1)) {
14247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14248 }
14249 arg1 = (PLBOOL)(val1);
14250 plxormod(arg1,arg2);
14251 resultobj = SWIG_Py_Void();
14252 if (SWIG_IsTmpObj(res2)) {
14253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14254 } else {
14255 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14257 }
14258 return resultobj;
14259fail:
14260 return NULL;
14261}
14262
14263
14264SWIGINTERN PyObject *_wrap_plmap(PyObject *self, PyObject *args) {
14265 PyObject *resultobj = 0;
14266 mapform_func arg1 = (mapform_func) 0 ;
14267 char *arg2 = (char *) 0 ;
14268 PLFLT arg3 ;
14269 PLFLT arg4 ;
14270 PLFLT arg5 ;
14271 PLFLT arg6 ;
14272 int res2 ;
14273 char *buf2 = 0 ;
14274 int alloc2 = 0 ;
14275 double val3 ;
14276 int ecode3 = 0 ;
14277 double val4 ;
14278 int ecode4 = 0 ;
14279 double val5 ;
14280 int ecode5 = 0 ;
14281 double val6 ;
14282 int ecode6 = 0 ;
14283 PyObject *swig_obj[6] ;
14284
14285 (void)self;
14286 if (!SWIG_Python_UnpackTuple(args, "plmap", 6, 6, swig_obj)) SWIG_fail;
14287 {
14288 // it must be a callable or none
14289 if ( swig_obj[0] == Py_None )
14290 {
14291 arg1 = NULL;
14292 }
14293 else
14294 {
14295 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14296 {
14297 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14298 return NULL;
14299 }
14300 arg1 = marshal_mapform( swig_obj[0] );
14301 }
14302 }
14303 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14304 if (!SWIG_IsOK(res2)) {
14305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14306 }
14307 arg2 = (char *)(buf2);
14308 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14309 if (!SWIG_IsOK(ecode3)) {
14310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14311 }
14312 arg3 = (PLFLT)(val3);
14313 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14314 if (!SWIG_IsOK(ecode4)) {
14315 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14316 }
14317 arg4 = (PLFLT)(val4);
14318 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14319 if (!SWIG_IsOK(ecode5)) {
14320 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14321 }
14322 arg5 = (PLFLT)(val5);
14323 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14324 if (!SWIG_IsOK(ecode6)) {
14325 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14326 }
14327 arg6 = (PLFLT)(val6);
14328 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14329 resultobj = SWIG_Py_Void();
14330 {
14332 }
14333 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14334 return resultobj;
14335fail:
14336 {
14338 }
14339 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14340 return NULL;
14341}
14342
14343
14344SWIGINTERN PyObject *_wrap_plmapline(PyObject *self, PyObject *args) {
14345 PyObject *resultobj = 0;
14346 mapform_func arg1 = (mapform_func) 0 ;
14347 char *arg2 = (char *) 0 ;
14348 PLFLT arg3 ;
14349 PLFLT arg4 ;
14350 PLFLT arg5 ;
14351 PLFLT arg6 ;
14352 PLINT *arg7 = (PLINT *) 0 ;
14353 PLINT arg8 ;
14354 int res2 ;
14355 char *buf2 = 0 ;
14356 int alloc2 = 0 ;
14357 double val3 ;
14358 int ecode3 = 0 ;
14359 double val4 ;
14360 int ecode4 = 0 ;
14361 double val5 ;
14362 int ecode5 = 0 ;
14363 double val6 ;
14364 int ecode6 = 0 ;
14365 PyArrayObject *tmp7 = NULL ;
14366 PyObject *swig_obj[7] ;
14367
14368 (void)self;
14369 if (!SWIG_Python_UnpackTuple(args, "plmapline", 7, 7, swig_obj)) SWIG_fail;
14370 {
14371 // it must be a callable or none
14372 if ( swig_obj[0] == Py_None )
14373 {
14374 arg1 = NULL;
14375 }
14376 else
14377 {
14378 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14379 {
14380 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14381 return NULL;
14382 }
14383 arg1 = marshal_mapform( swig_obj[0] );
14384 }
14385 }
14386 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14387 if (!SWIG_IsOK(res2)) {
14388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
14389 }
14390 arg2 = (char *)(buf2);
14391 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14392 if (!SWIG_IsOK(ecode3)) {
14393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
14394 }
14395 arg3 = (PLFLT)(val3);
14396 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14397 if (!SWIG_IsOK(ecode4)) {
14398 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
14399 }
14400 arg4 = (PLFLT)(val4);
14401 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14402 if (!SWIG_IsOK(ecode5)) {
14403 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
14404 }
14405 arg5 = (PLFLT)(val5);
14406 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14407 if (!SWIG_IsOK(ecode6)) {
14408 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14409 }
14410 arg6 = (PLFLT)(val6);
14411 {
14412 if ( swig_obj[6] != Py_None )
14413 {
14414 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14415 if ( tmp7 == NULL )
14416 return NULL;
14417 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14418 arg8 = PyArray_DIMS( tmp7 )[0];
14419 }
14420 else
14421 {
14422 arg7 = NULL;
14423 arg8 = 0;
14424 }
14425 }
14426 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14427 resultobj = SWIG_Py_Void();
14428 {
14430 }
14431 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14432 {
14433 Py_CLEAR( tmp7 );
14434 }
14435 return resultobj;
14436fail:
14437 {
14439 }
14440 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14441 {
14442 Py_CLEAR( tmp7 );
14443 }
14444 return NULL;
14445}
14446
14447
14448SWIGINTERN PyObject *_wrap_plmapstring(PyObject *self, PyObject *args) {
14449 PyObject *resultobj = 0;
14450 mapform_func arg1 = (mapform_func) 0 ;
14451 char *arg2 = (char *) 0 ;
14452 char *arg3 = (char *) 0 ;
14453 PLFLT arg4 ;
14454 PLFLT arg5 ;
14455 PLFLT arg6 ;
14456 PLFLT arg7 ;
14457 PLINT *arg8 = (PLINT *) 0 ;
14458 PLINT arg9 ;
14459 int res2 ;
14460 char *buf2 = 0 ;
14461 int alloc2 = 0 ;
14462 int res3 ;
14463 char *buf3 = 0 ;
14464 int alloc3 = 0 ;
14465 double val4 ;
14466 int ecode4 = 0 ;
14467 double val5 ;
14468 int ecode5 = 0 ;
14469 double val6 ;
14470 int ecode6 = 0 ;
14471 double val7 ;
14472 int ecode7 = 0 ;
14473 PyArrayObject *tmp8 = NULL ;
14474 PyObject *swig_obj[8] ;
14475
14476 (void)self;
14477 if (!SWIG_Python_UnpackTuple(args, "plmapstring", 8, 8, swig_obj)) SWIG_fail;
14478 {
14479 // it must be a callable or none
14480 if ( swig_obj[0] == Py_None )
14481 {
14482 arg1 = NULL;
14483 }
14484 else
14485 {
14486 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14487 {
14488 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14489 return NULL;
14490 }
14491 arg1 = marshal_mapform( swig_obj[0] );
14492 }
14493 }
14494 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14495 if (!SWIG_IsOK(res2)) {
14496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14497 }
14498 arg2 = (char *)(buf2);
14499 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
14500 if (!SWIG_IsOK(res3)) {
14501 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14502 }
14503 arg3 = (char *)(buf3);
14504 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14505 if (!SWIG_IsOK(ecode4)) {
14506 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14507 }
14508 arg4 = (PLFLT)(val4);
14509 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14510 if (!SWIG_IsOK(ecode5)) {
14511 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14512 }
14513 arg5 = (PLFLT)(val5);
14514 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14515 if (!SWIG_IsOK(ecode6)) {
14516 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14517 }
14518 arg6 = (PLFLT)(val6);
14519 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14520 if (!SWIG_IsOK(ecode7)) {
14521 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14522 }
14523 arg7 = (PLFLT)(val7);
14524 {
14525 if ( swig_obj[7] != Py_None )
14526 {
14527 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
14528 if ( tmp8 == NULL )
14529 return NULL;
14530 arg8 = (PLINT *) PyArray_DATA( tmp8 );
14531 arg9 = PyArray_DIMS( tmp8 )[0];
14532 }
14533 else
14534 {
14535 arg8 = NULL;
14536 arg9 = 0;
14537 }
14538 }
14539 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14540 resultobj = SWIG_Py_Void();
14541 {
14543 }
14544 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14545 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14546 {
14547 Py_CLEAR( tmp8 );
14548 }
14549 return resultobj;
14550fail:
14551 {
14553 }
14554 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14555 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14556 {
14557 Py_CLEAR( tmp8 );
14558 }
14559 return NULL;
14560}
14561
14562
14563SWIGINTERN PyObject *_wrap_plmaptex(PyObject *self, PyObject *args) {
14564 PyObject *resultobj = 0;
14565 mapform_func arg1 = (mapform_func) 0 ;
14566 char *arg2 = (char *) 0 ;
14567 PLFLT arg3 ;
14568 PLFLT arg4 ;
14569 PLFLT arg5 ;
14570 char *arg6 = (char *) 0 ;
14571 PLFLT arg7 ;
14572 PLFLT arg8 ;
14573 PLFLT arg9 ;
14574 PLFLT arg10 ;
14575 PLINT arg11 ;
14576 int res2 ;
14577 char *buf2 = 0 ;
14578 int alloc2 = 0 ;
14579 double val3 ;
14580 int ecode3 = 0 ;
14581 double val4 ;
14582 int ecode4 = 0 ;
14583 double val5 ;
14584 int ecode5 = 0 ;
14585 int res6 ;
14586 char *buf6 = 0 ;
14587 int alloc6 = 0 ;
14588 double val7 ;
14589 int ecode7 = 0 ;
14590 double val8 ;
14591 int ecode8 = 0 ;
14592 double val9 ;
14593 int ecode9 = 0 ;
14594 double val10 ;
14595 int ecode10 = 0 ;
14596 int val11 ;
14597 int ecode11 = 0 ;
14598 PyObject *swig_obj[11] ;
14599
14600 (void)self;
14601 if (!SWIG_Python_UnpackTuple(args, "plmaptex", 11, 11, swig_obj)) SWIG_fail;
14602 {
14603 // it must be a callable or none
14604 if ( swig_obj[0] == Py_None )
14605 {
14606 arg1 = NULL;
14607 }
14608 else
14609 {
14610 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14611 {
14612 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14613 return NULL;
14614 }
14615 arg1 = marshal_mapform( swig_obj[0] );
14616 }
14617 }
14618 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14619 if (!SWIG_IsOK(res2)) {
14620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14621 }
14622 arg2 = (char *)(buf2);
14623 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14624 if (!SWIG_IsOK(ecode3)) {
14625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14626 }
14627 arg3 = (PLFLT)(val3);
14628 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14629 if (!SWIG_IsOK(ecode4)) {
14630 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14631 }
14632 arg4 = (PLFLT)(val4);
14633 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14634 if (!SWIG_IsOK(ecode5)) {
14635 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14636 }
14637 arg5 = (PLFLT)(val5);
14638 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
14639 if (!SWIG_IsOK(res6)) {
14640 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14641 }
14642 arg6 = (char *)(buf6);
14643 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14644 if (!SWIG_IsOK(ecode7)) {
14645 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14646 }
14647 arg7 = (PLFLT)(val7);
14648 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14649 if (!SWIG_IsOK(ecode8)) {
14650 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14651 }
14652 arg8 = (PLFLT)(val8);
14653 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14654 if (!SWIG_IsOK(ecode9)) {
14655 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14656 }
14657 arg9 = (PLFLT)(val9);
14658 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14659 if (!SWIG_IsOK(ecode10)) {
14660 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14661 }
14662 arg10 = (PLFLT)(val10);
14663 ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
14664 if (!SWIG_IsOK(ecode11)) {
14665 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14666 }
14667 arg11 = (PLINT)(val11);
14668 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14669 resultobj = SWIG_Py_Void();
14670 {
14672 }
14673 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14674 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14675 return resultobj;
14676fail:
14677 {
14679 }
14680 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14681 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14682 return NULL;
14683}
14684
14685
14686SWIGINTERN PyObject *_wrap_plmapfill(PyObject *self, PyObject *args) {
14687 PyObject *resultobj = 0;
14688 mapform_func arg1 = (mapform_func) 0 ;
14689 char *arg2 = (char *) 0 ;
14690 PLFLT arg3 ;
14691 PLFLT arg4 ;
14692 PLFLT arg5 ;
14693 PLFLT arg6 ;
14694 PLINT *arg7 = (PLINT *) 0 ;
14695 PLINT arg8 ;
14696 int res2 ;
14697 char *buf2 = 0 ;
14698 int alloc2 = 0 ;
14699 double val3 ;
14700 int ecode3 = 0 ;
14701 double val4 ;
14702 int ecode4 = 0 ;
14703 double val5 ;
14704 int ecode5 = 0 ;
14705 double val6 ;
14706 int ecode6 = 0 ;
14707 PyArrayObject *tmp7 = NULL ;
14708 PyObject *swig_obj[7] ;
14709
14710 (void)self;
14711 if (!SWIG_Python_UnpackTuple(args, "plmapfill", 7, 7, swig_obj)) SWIG_fail;
14712 {
14713 // it must be a callable or none
14714 if ( swig_obj[0] == Py_None )
14715 {
14716 arg1 = NULL;
14717 }
14718 else
14719 {
14720 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14721 {
14722 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14723 return NULL;
14724 }
14725 arg1 = marshal_mapform( swig_obj[0] );
14726 }
14727 }
14728 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14729 if (!SWIG_IsOK(res2)) {
14730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14731 }
14732 arg2 = (char *)(buf2);
14733 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14734 if (!SWIG_IsOK(ecode3)) {
14735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14736 }
14737 arg3 = (PLFLT)(val3);
14738 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14739 if (!SWIG_IsOK(ecode4)) {
14740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14741 }
14742 arg4 = (PLFLT)(val4);
14743 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14744 if (!SWIG_IsOK(ecode5)) {
14745 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14746 }
14747 arg5 = (PLFLT)(val5);
14748 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14749 if (!SWIG_IsOK(ecode6)) {
14750 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14751 }
14752 arg6 = (PLFLT)(val6);
14753 {
14754 if ( swig_obj[6] != Py_None )
14755 {
14756 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14757 if ( tmp7 == NULL )
14758 return NULL;
14759 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14760 arg8 = PyArray_DIMS( tmp7 )[0];
14761 }
14762 else
14763 {
14764 arg7 = NULL;
14765 arg8 = 0;
14766 }
14767 }
14768 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14769 resultobj = SWIG_Py_Void();
14770 {
14772 }
14773 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14774 {
14775 Py_CLEAR( tmp7 );
14776 }
14777 return resultobj;
14778fail:
14779 {
14781 }
14782 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14783 {
14784 Py_CLEAR( tmp7 );
14785 }
14786 return NULL;
14787}
14788
14789
14790SWIGINTERN PyObject *_wrap_plmeridians(PyObject *self, PyObject *args) {
14791 PyObject *resultobj = 0;
14792 mapform_func arg1 = (mapform_func) 0 ;
14793 PLFLT arg2 ;
14794 PLFLT arg3 ;
14795 PLFLT arg4 ;
14796 PLFLT arg5 ;
14797 PLFLT arg6 ;
14798 PLFLT arg7 ;
14799 double val2 ;
14800 int ecode2 = 0 ;
14801 double val3 ;
14802 int ecode3 = 0 ;
14803 double val4 ;
14804 int ecode4 = 0 ;
14805 double val5 ;
14806 int ecode5 = 0 ;
14807 double val6 ;
14808 int ecode6 = 0 ;
14809 double val7 ;
14810 int ecode7 = 0 ;
14811 PyObject *swig_obj[7] ;
14812
14813 (void)self;
14814 if (!SWIG_Python_UnpackTuple(args, "plmeridians", 7, 7, swig_obj)) SWIG_fail;
14815 {
14816 // it must be a callable or none
14817 if ( swig_obj[0] == Py_None )
14818 {
14819 arg1 = NULL;
14820 }
14821 else
14822 {
14823 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14824 {
14825 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14826 return NULL;
14827 }
14828 arg1 = marshal_mapform( swig_obj[0] );
14829 }
14830 }
14831 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14832 if (!SWIG_IsOK(ecode2)) {
14833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14834 }
14835 arg2 = (PLFLT)(val2);
14836 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14837 if (!SWIG_IsOK(ecode3)) {
14838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14839 }
14840 arg3 = (PLFLT)(val3);
14841 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14842 if (!SWIG_IsOK(ecode4)) {
14843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14844 }
14845 arg4 = (PLFLT)(val4);
14846 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14847 if (!SWIG_IsOK(ecode5)) {
14848 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14849 }
14850 arg5 = (PLFLT)(val5);
14851 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14852 if (!SWIG_IsOK(ecode6)) {
14853 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14854 }
14855 arg6 = (PLFLT)(val6);
14856 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14857 if (!SWIG_IsOK(ecode7)) {
14858 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14859 }
14860 arg7 = (PLFLT)(val7);
14861 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14862 resultobj = SWIG_Py_Void();
14863 {
14865 }
14866 return resultobj;
14867fail:
14868 {
14870 }
14871 return NULL;
14872}
14873
14874
14875SWIGINTERN PyObject *_wrap_plimage(PyObject *self, PyObject *args) {
14876 PyObject *resultobj = 0;
14877 PLFLT **arg1 = (PLFLT **) 0 ;
14878 PLINT arg2 ;
14879 PLINT arg3 ;
14880 PLFLT arg4 ;
14881 PLFLT arg5 ;
14882 PLFLT arg6 ;
14883 PLFLT arg7 ;
14884 PLFLT arg8 ;
14885 PLFLT arg9 ;
14886 PLFLT arg10 ;
14887 PLFLT arg11 ;
14888 PLFLT arg12 ;
14889 PLFLT arg13 ;
14890 PyArrayObject *tmp1 = NULL ;
14891 double val4 ;
14892 int ecode4 = 0 ;
14893 double val5 ;
14894 int ecode5 = 0 ;
14895 double val6 ;
14896 int ecode6 = 0 ;
14897 double val7 ;
14898 int ecode7 = 0 ;
14899 double val8 ;
14900 int ecode8 = 0 ;
14901 double val9 ;
14902 int ecode9 = 0 ;
14903 double val10 ;
14904 int ecode10 = 0 ;
14905 double val11 ;
14906 int ecode11 = 0 ;
14907 double val12 ;
14908 int ecode12 = 0 ;
14909 double val13 ;
14910 int ecode13 = 0 ;
14911 PyObject *swig_obj[11] ;
14912
14913 (void)self;
14914 if (!SWIG_Python_UnpackTuple(args, "plimage", 11, 11, swig_obj)) SWIG_fail;
14915 {
14916 int i, size;
14917 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14918 if ( tmp1 == NULL )
14919 return NULL;
14920 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14921 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14922 size = arg3;
14923 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14924 for ( i = 0; i < arg2; i++ )
14925 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14926 }
14927 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14928 if (!SWIG_IsOK(ecode4)) {
14929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14930 }
14931 arg4 = (PLFLT)(val4);
14932 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14933 if (!SWIG_IsOK(ecode5)) {
14934 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14935 }
14936 arg5 = (PLFLT)(val5);
14937 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14938 if (!SWIG_IsOK(ecode6)) {
14939 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14940 }
14941 arg6 = (PLFLT)(val6);
14942 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14943 if (!SWIG_IsOK(ecode7)) {
14944 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14945 }
14946 arg7 = (PLFLT)(val7);
14947 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14948 if (!SWIG_IsOK(ecode8)) {
14949 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14950 }
14951 arg8 = (PLFLT)(val8);
14952 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14953 if (!SWIG_IsOK(ecode9)) {
14954 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14955 }
14956 arg9 = (PLFLT)(val9);
14957 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14958 if (!SWIG_IsOK(ecode10)) {
14959 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14960 }
14961 arg10 = (PLFLT)(val10);
14962 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14963 if (!SWIG_IsOK(ecode11)) {
14964 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14965 }
14966 arg11 = (PLFLT)(val11);
14967 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
14968 if (!SWIG_IsOK(ecode12)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14970 }
14971 arg12 = (PLFLT)(val12);
14972 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
14973 if (!SWIG_IsOK(ecode13)) {
14974 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14975 }
14976 arg13 = (PLFLT)(val13);
14977 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14978 resultobj = SWIG_Py_Void();
14979 {
14980 Py_CLEAR( tmp1 );
14981 free( arg1 );
14982 }
14983 return resultobj;
14984fail:
14985 {
14986 Py_CLEAR( tmp1 );
14987 free( arg1 );
14988 }
14989 return NULL;
14990}
14991
14992
14993SWIGINTERN PyObject *_wrap_plimagefr(PyObject *self, PyObject *args) {
14994 PyObject *resultobj = 0;
14995 PLFLT **arg1 = (PLFLT **) 0 ;
14996 PLINT arg2 ;
14997 PLINT arg3 ;
14998 PLFLT arg4 ;
14999 PLFLT arg5 ;
15000 PLFLT arg6 ;
15001 PLFLT arg7 ;
15002 PLFLT arg8 ;
15003 PLFLT arg9 ;
15004 PLFLT arg10 ;
15005 PLFLT arg11 ;
15006 pltr_func arg12 = (pltr_func) 0 ;
15007 PLPointer arg13 = (PLPointer) 0 ;
15008 PyArrayObject *tmp1 = NULL ;
15009 double val4 ;
15010 int ecode4 = 0 ;
15011 double val5 ;
15012 int ecode5 = 0 ;
15013 double val6 ;
15014 int ecode6 = 0 ;
15015 double val7 ;
15016 int ecode7 = 0 ;
15017 double val8 ;
15018 int ecode8 = 0 ;
15019 double val9 ;
15020 int ecode9 = 0 ;
15021 double val10 ;
15022 int ecode10 = 0 ;
15023 double val11 ;
15024 int ecode11 = 0 ;
15025 PyObject *swig_obj[11] ;
15026
15027 {
15028 python_pltr = 0;
15029 arg12 = NULL;
15030 }
15031 {
15032 arg13 = NULL;
15033 }
15034 (void)self;
15035 if (!SWIG_Python_UnpackTuple(args, "plimagefr", 9, 11, swig_obj)) SWIG_fail;
15036 {
15037 int i, size;
15038 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15039 if ( tmp1 == NULL )
15040 return NULL;
15041 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15042 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15043 size = arg3;
15044 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15045 for ( i = 0; i < arg2; i++ )
15046 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15047 }
15048 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
15049 if (!SWIG_IsOK(ecode4)) {
15050 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15051 }
15052 arg4 = (PLFLT)(val4);
15053 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
15054 if (!SWIG_IsOK(ecode5)) {
15055 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15056 }
15057 arg5 = (PLFLT)(val5);
15058 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
15059 if (!SWIG_IsOK(ecode6)) {
15060 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15061 }
15062 arg6 = (PLFLT)(val6);
15063 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
15064 if (!SWIG_IsOK(ecode7)) {
15065 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15066 }
15067 arg7 = (PLFLT)(val7);
15068 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
15069 if (!SWIG_IsOK(ecode8)) {
15070 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15071 }
15072 arg8 = (PLFLT)(val8);
15073 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
15074 if (!SWIG_IsOK(ecode9)) {
15075 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15076 }
15077 arg9 = (PLFLT)(val9);
15078 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
15079 if (!SWIG_IsOK(ecode10)) {
15080 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15081 }
15082 arg10 = (PLFLT)(val10);
15083 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
15084 if (!SWIG_IsOK(ecode11)) {
15085 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15086 }
15087 arg11 = (PLFLT)(val11);
15088 if (swig_obj[9]) {
15089 {
15090 // it must be a callable or None
15091 if ( swig_obj[9] == Py_None )
15092 {
15093 arg12 = NULL;
15094 }
15095 else
15096 {
15097 if ( !PyCallable_Check( (PyObject *) swig_obj[9] ) )
15098 {
15099 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
15100 return NULL;
15101 }
15102 arg12 = marshal_pltr( swig_obj[9] );
15103 }
15104 }
15105 }
15106 if (swig_obj[10]) {
15107 {
15108 if ( swig_obj[10] == Py_None )
15109 arg13 = NULL;
15110 else
15111 {
15112 arg13 = marshal_PLPointer( swig_obj[10], 1 );
15113 }
15114 }
15115 }
15116 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15117 resultobj = SWIG_Py_Void();
15118 {
15119 Py_CLEAR( tmp1 );
15120 free( arg1 );
15121 }
15122 {
15123 cleanup_pltr();
15124 }
15125 {
15127 }
15128 return resultobj;
15129fail:
15130 {
15131 Py_CLEAR( tmp1 );
15132 free( arg1 );
15133 }
15134 {
15135 cleanup_pltr();
15136 }
15137 {
15139 }
15140 return NULL;
15141}
15142
15143
15144SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *self, PyObject *args) {
15145 PyObject *resultobj = 0;
15146
15147 (void)self;
15148 if (!SWIG_Python_UnpackTuple(args, "plClearOpts", 0, 0, 0)) SWIG_fail;
15149 plClearOpts();
15150 resultobj = SWIG_Py_Void();
15151 return resultobj;
15152fail:
15153 return NULL;
15154}
15155
15156
15157SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *self, PyObject *args) {
15158 PyObject *resultobj = 0;
15159
15160 (void)self;
15161 if (!SWIG_Python_UnpackTuple(args, "plResetOpts", 0, 0, 0)) SWIG_fail;
15162 plResetOpts();
15163 resultobj = SWIG_Py_Void();
15164 return resultobj;
15165fail:
15166 return NULL;
15167}
15168
15169
15170SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *self, PyObject *args) {
15171 PyObject *resultobj = 0;
15172 char *arg1 = (char *) 0 ;
15173 char *arg2 = (char *) 0 ;
15174 int res1 ;
15175 char *buf1 = 0 ;
15176 int alloc1 = 0 ;
15177 int res2 ;
15178 char *buf2 = 0 ;
15179 int alloc2 = 0 ;
15180 PyObject *swig_obj[2] ;
15181
15182 (void)self;
15183 if (!SWIG_Python_UnpackTuple(args, "plSetUsage", 2, 2, swig_obj)) SWIG_fail;
15184 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
15185 if (!SWIG_IsOK(res1)) {
15186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
15187 }
15188 arg1 = (char *)(buf1);
15189 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
15190 if (!SWIG_IsOK(res2)) {
15191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
15192 }
15193 arg2 = (char *)(buf2);
15194 plSetUsage((char const *)arg1,(char const *)arg2);
15195 resultobj = SWIG_Py_Void();
15196 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15197 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15198 return resultobj;
15199fail:
15200 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15201 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15202 return NULL;
15203}
15204
15205
15206SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *self, PyObject *args) {
15207 PyObject *resultobj = 0;
15208
15209 (void)self;
15210 if (!SWIG_Python_UnpackTuple(args, "plOptUsage", 0, 0, 0)) SWIG_fail;
15211 plOptUsage();
15212 resultobj = SWIG_Py_Void();
15213 return resultobj;
15214fail:
15215 return NULL;
15216}
15217
15218
15219SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *self, PyObject *args) {
15220 PyObject *resultobj = 0;
15221 PLFLT **arg1 = (PLFLT **) 0 ;
15222 PLINT arg2 ;
15223 PLINT arg3 ;
15224 PLFLT *arg4 = (PLFLT *) 0 ;
15225 PLFLT *arg5 = (PLFLT *) 0 ;
15226 PyArrayObject *tmp1 = NULL ;
15227 PLFLT temp4 ;
15228 int res4 = SWIG_TMPOBJ ;
15229 PLFLT temp5 ;
15230 int res5 = SWIG_TMPOBJ ;
15231 PyObject *swig_obj[1] ;
15232
15233 arg4 = &temp4;
15234 arg5 = &temp5;
15235 (void)self;
15236 if (!args) SWIG_fail;
15237 swig_obj[0] = args;
15238 {
15239 int i, size;
15240 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15241 if ( tmp1 == NULL )
15242 return NULL;
15243 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15244 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15245 size = arg3;
15246 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15247 for ( i = 0; i < arg2; i++ )
15248 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15249 }
15250 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
15251 resultobj = SWIG_Py_Void();
15252 if (SWIG_IsTmpObj(res4)) {
15253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
15254 } else {
15255 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15257 }
15258 if (SWIG_IsTmpObj(res5)) {
15259 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
15260 } else {
15261 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15262 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
15263 }
15264 {
15265 Py_CLEAR( tmp1 );
15266 free( arg1 );
15267 }
15268 return resultobj;
15269fail:
15270 {
15271 Py_CLEAR( tmp1 );
15272 free( arg1 );
15273 }
15274 return NULL;
15275}
15276
15277
15278SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *self, PyObject *args) {
15279 PyObject *resultobj = 0;
15280 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15281 void *argp1 = 0 ;
15282 int res1 = 0 ;
15283 PyObject *swig_obj[1] ;
15284 PLINT result;
15285
15286 (void)self;
15287 if (!args) SWIG_fail;
15288 swig_obj[0] = args;
15289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15290 if (!SWIG_IsOK(res1)) {
15291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15292 }
15293 arg1 = (PLGraphicsIn *)(argp1);
15294 result = (PLINT)plGetCursor(arg1);
15295 resultobj = SWIG_From_int((int)(result));
15296 return resultobj;
15297fail:
15298 return NULL;
15299}
15300
15301
15302static PyMethodDef SwigMethods[] = {
15303 { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
15304 { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
15305 { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
15306 { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
15307 { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_O, NULL},
15308 { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
15309 { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_O, NULL},
15310 { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
15311 { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_O, NULL},
15312 { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
15313 { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_O, NULL},
15314 { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
15315 { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_O, NULL},
15316 { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
15317 { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_O, NULL},
15318 { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
15319 { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_O, NULL},
15320 { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
15321 { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_O, NULL},
15322 { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
15323 { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_O, NULL},
15324 { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
15325 { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_O, NULL},
15326 { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
15327 { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_O, NULL},
15328 { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
15329 { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_O, NULL},
15330 { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_NOARGS, NULL},
15331 { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_O, NULL},
15332 { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_O, NULL},
15333 { "PLGraphicsIn_swiginit", PLGraphicsIn_swiginit, METH_VARARGS, NULL},
15334 { "plsxwin", _wrap_plsxwin, METH_O, NULL},
15335 { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, "\n"
15336 "Set format of numerical label for contours\n"
15337 "\n"
15338 "DESCRIPTION:\n"
15339 "\n"
15340 " Set format of numerical label for contours.\n"
15341 "\n"
15342 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15343 "\n"
15344 " This function is used example 9.\n"
15345 "\n"
15346 "\n"
15347 "\n"
15348 "SYNOPSIS:\n"
15349 "\n"
15350 "pl_setcontlabelformat(lexp, sigdig)\n"
15351 "\n"
15352 "ARGUMENTS:\n"
15353 "\n"
15354 " lexp (PLINT, input) : If the contour numerical label is greater\n"
15355 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15356 " format is used. Default value of lexp is 4.\n"
15357 "\n"
15358 " sigdig (PLINT, input) : Number of significant digits. Default\n"
15359 " value is 2.\n"
15360 "\n"
15361 ""},
15362 { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, "\n"
15363 "Set parameters of contour labelling other than format of numerical label\n"
15364 "\n"
15365 "DESCRIPTION:\n"
15366 "\n"
15367 " Set parameters of contour labelling other than those handled by\n"
15368 " pl_setcontlabelformat.\n"
15369 "\n"
15370 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15371 "\n"
15372 " This function is used in example 9.\n"
15373 "\n"
15374 "\n"
15375 "\n"
15376 "SYNOPSIS:\n"
15377 "\n"
15378 "pl_setcontlabelparam(offset, size, spacing, active)\n"
15379 "\n"
15380 "ARGUMENTS:\n"
15381 "\n"
15382 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15383 " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
15384 "\n"
15385 " size (PLFLT, input) : Font height for contour labels (normalized).\n"
15386 " Default value is 0.3.\n"
15387 "\n"
15388 " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
15389 " Default value is 0.1.\n"
15390 "\n"
15391 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15392 " contour labels on. Default is off (0).\n"
15393 "\n"
15394 ""},
15395 { "pladv", _wrap_pladv, METH_O, "\n"
15396 "Advance the (sub-)page\n"
15397 "\n"
15398 "DESCRIPTION:\n"
15399 "\n"
15400 " Advances to the next subpage if sub=0, performing a page advance if\n"
15401 " there are no remaining subpages on the current page. If subpages\n"
15402 " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15403 " PLplot switches to the specified subpage. Note that this allows you\n"
15404 " to overwrite a plot on the specified subpage; if this is not what you\n"
15405 " intended, use pleop followed by plbop to first advance the page. This\n"
15406 " routine is called automatically (with page=0) by plenv, but if plenv\n"
15407 " is not used, pladv must be called after initializing PLplot but before\n"
15408 " defining the viewport.\n"
15409 "\n"
15410 " Redacted form: pladv(page)\n"
15411 "\n"
15412 " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
15413 " 29, and 31.\n"
15414 "\n"
15415 "\n"
15416 "\n"
15417 "SYNOPSIS:\n"
15418 "\n"
15419 "pladv(page)\n"
15420 "\n"
15421 "ARGUMENTS:\n"
15422 "\n"
15423 " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15424 " in the top left corner and increasing along the rows) to which to\n"
15425 " advance. Set to zero to advance to the next subpage (or to the\n"
15426 " next page if subpages are not being used).\n"
15427 "\n"
15428 ""},
15429 { "plarc", _wrap_plarc, METH_VARARGS, "\n"
15430 "Draw a circular or elliptical arc\n"
15431 "\n"
15432 "DESCRIPTION:\n"
15433 "\n"
15434 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15435 " semiminor axis b, starting at angle1 and ending at angle2.\n"
15436 "\n"
15437 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15438 " fill)\n"
15439 "\n"
15440 "\n"
15441 " This function is used in examples 3 and 27.\n"
15442 "\n"
15443 "\n"
15444 "\n"
15445 "SYNOPSIS:\n"
15446 "\n"
15447 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15448 "\n"
15449 "ARGUMENTS:\n"
15450 "\n"
15451 " x (PLFLT, input) : X coordinate of arc center.\n"
15452 "\n"
15453 " y (PLFLT, input) : Y coordinate of arc center.\n"
15454 "\n"
15455 " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15456 "\n"
15457 " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15458 "\n"
15459 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15460 " semimajor axis.\n"
15461 "\n"
15462 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15463 " semimajor axis.\n"
15464 "\n"
15465 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15466 " X-axis.\n"
15467 "\n"
15468 " fill (PLBOOL, input) : Draw a filled arc.\n"
15469 "\n"
15470 ""},
15471 { "plaxes", _wrap_plaxes, METH_VARARGS, "\n"
15472 "Draw a box with axes, etc. with arbitrary origin\n"
15473 "\n"
15474 "DESCRIPTION:\n"
15475 "\n"
15476 " Draws a box around the currently defined viewport with arbitrary\n"
15477 " world-coordinate origin specified by x0 and y0 and labels it with\n"
15478 " world coordinate values appropriate to the window. Thus plaxes should\n"
15479 " only be called after defining both viewport and window. The ascii\n"
15480 " character strings xopt and yopt specify how the box should be drawn as\n"
15481 " described below. If ticks and/or subticks are to be drawn for a\n"
15482 " particular axis, the tick intervals and number of subintervals may be\n"
15483 " specified explicitly, or they may be defaulted by setting the\n"
15484 " appropriate arguments to zero.\n"
15485 "\n"
15486 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15487 " ytick, nysub)\n"
15488 "\n"
15489 "\n"
15490 " This function is not used in any examples.\n"
15491 "\n"
15492 "\n"
15493 "\n"
15494 "SYNOPSIS:\n"
15495 "\n"
15496 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15497 "\n"
15498 "ARGUMENTS:\n"
15499 "\n"
15500 " x0 (PLFLT, input) : World X coordinate of origin.\n"
15501 "\n"
15502 " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15503 "\n"
15504 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15505 " options for the x axis. The string can include any combination of\n"
15506 " the following letters (upper or lower case) in any order: a: Draws\n"
15507 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15508 " (x=0).\n"
15509 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15510 " c: Draws top (X) or right (Y) edge of frame.\n"
15511 " d: Plot labels as date / time. Values are assumed to be\n"
15512 " seconds since the epoch (as used by gmtime).\n"
15513 " f: Always use fixed point numeric labels.\n"
15514 " g: Draws a grid at the major tick interval.\n"
15515 " h: Draws a grid at the minor tick interval.\n"
15516 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15517 " inwards.\n"
15518 " l: Labels axis logarithmically. This only affects the labels,\n"
15519 " not the data, and so it is necessary to compute the logarithms\n"
15520 " of data points before passing them to any of the drawing\n"
15521 " routines.\n"
15522 " m: Writes numeric labels at major tick intervals in the\n"
15523 " unconventional location (above box for X, right of box for Y).\n"
15524 " n: Writes numeric labels at major tick intervals in the\n"
15525 " conventional location (below box for X, left of box for Y).\n"
15526 " o: Use custom labelling function to generate axis label text.\n"
15527 " The custom labelling function can be defined with the\n"
15528 " plslabelfunc command.\n"
15529 " s: Enables subticks between major ticks, only valid if t is\n"
15530 " also specified.\n"
15531 " t: Draws major ticks.\n"
15532 " u: Exactly like \"b\" except don't draw edge line.\n"
15533 " w: Exactly like \"c\" except don't draw edge line.\n"
15534 " x: Exactly like \"t\" (including the side effect of the\n"
15535 " numerical labels for the major ticks) except exclude drawing\n"
15536 " the major and minor tick marks.\n"
15537 "\n"
15538 "\n"
15539 " xtick (PLFLT, input) : World coordinate interval between major\n"
15540 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15541 " generates a suitable tick interval.\n"
15542 "\n"
15543 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15544 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15545 " generates a suitable minor tick interval.\n"
15546 "\n"
15547 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15548 " options for the y axis. The string can include any combination of\n"
15549 " the letters defined above for xopt, and in addition may contain:\n"
15550 " v: Write numeric labels for the y axis parallel to the base of the\n"
15551 " graph, rather than parallel to the axis.\n"
15552 "\n"
15553 "\n"
15554 " ytick (PLFLT, input) : World coordinate interval between major\n"
15555 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15556 " generates a suitable tick interval.\n"
15557 "\n"
15558 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15559 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15560 " generates a suitable minor tick interval.\n"
15561 "\n"
15562 ""},
15563 { "plbin", _wrap_plbin, METH_VARARGS, "\n"
15564 "Plot a histogram from binned data\n"
15565 "\n"
15566 "DESCRIPTION:\n"
15567 "\n"
15568 " Plots a histogram consisting of nbin bins. The value associated with\n"
15569 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15570 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15571 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15572 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15573 " placed midway between the values in the x vector. Also see plhist for\n"
15574 " drawing histograms from unbinned data.\n"
15575 "\n"
15576 " Redacted form: General: plbin(x, y, opt)\n"
15577 " Python: plbin(nbin, x, y, opt)\n"
15578 "\n"
15579 "\n"
15580 " This function is not used in any examples.\n"
15581 "\n"
15582 "\n"
15583 "\n"
15584 "SYNOPSIS:\n"
15585 "\n"
15586 "plbin(nbin, x, y, opt)\n"
15587 "\n"
15588 "ARGUMENTS:\n"
15589 "\n"
15590 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15591 " and y vectors.)\n"
15592 "\n"
15593 " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15594 " with bins. These must form a strictly increasing sequence.\n"
15595 "\n"
15596 " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15597 " proportional to the number of points in each bin. This is a PLFLT\n"
15598 " (instead of PLINT) vector so as to allow histograms of\n"
15599 " probabilities, etc.\n"
15600 "\n"
15601 " opt (PLINT, input) : Is a combination of several flags:\n"
15602 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15603 " outer bins are expanded to fill up the entire x-axis and bins of\n"
15604 " zero height are simply drawn.\n"
15605 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15606 " between the x values. If the values in x are equally spaced,\n"
15607 " the values are the center values of the bins.\n"
15608 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15609 " size as the ones inside.\n"
15610 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15611 " (there is a gap for such bins).\n"
15612 "\n"
15613 ""},
15614 { "plbtime", _wrap_plbtime, METH_O, "\n"
15615 "Calculate broken-down time from continuous time for the current stream\n"
15616 "\n"
15617 "DESCRIPTION:\n"
15618 "\n"
15619 " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15620 " continuous time, ctime for the current stream. This function is the\n"
15621 " inverse of plctime.\n"
15622 "\n"
15623 " The PLplot definition of broken-down time is a calendar time that\n"
15624 " completely ignores all time zone offsets, i.e., it is the user's\n"
15625 " responsibility to apply those offsets (if so desired) before using the\n"
15626 " PLplot time API. By default broken-down time is defined using the\n"
15627 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15628 " continuous time is defined as the number of seconds since the Unix\n"
15629 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15630 " broken-down and continuous time are possible, see plconfigtime.\n"
15631 "\n"
15632 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15633 " ctime)\n"
15634 "\n"
15635 "\n"
15636 " This function is used in example 29.\n"
15637 "\n"
15638 "\n"
15639 "\n"
15640 "SYNOPSIS:\n"
15641 "\n"
15642 "plbtime(year, month, day, hour, min, sec, ctime)\n"
15643 "\n"
15644 "ARGUMENTS:\n"
15645 "\n"
15646 " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15647 " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15648 " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15649 " BCE, etc.)\n"
15650 "\n"
15651 " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15652 " the year in the range from 0 (January) to 11 (December).\n"
15653 "\n"
15654 " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15655 " month in the range from 1 to 31.\n"
15656 "\n"
15657 " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15658 " day in the range from 0 to 23.\n"
15659 "\n"
15660 " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15661 " hour in the range from 0 to 59\n"
15662 "\n"
15663 " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15664 " minute in range from 0. to 60.\n"
15665 "\n"
15666 " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
15667 " time is calculated.\n"
15668 "\n"
15669 ""},
15670 { "plbop", _wrap_plbop, METH_NOARGS, "\n"
15671 "Begin a new page\n"
15672 "\n"
15673 "DESCRIPTION:\n"
15674 "\n"
15675 " Begins a new page. For a file driver, the output file is opened if\n"
15676 " necessary. Advancing the page via pleop and plbop is useful when a\n"
15677 " page break is desired at a particular point when plotting to subpages.\n"
15678 " Another use for pleop and plbop is when plotting pages to different\n"
15679 " files, since you can manually set the file name by calling plsfnam\n"
15680 " after the call to pleop. (In fact some drivers may only support a\n"
15681 " single page per file, making this a necessity.) One way to handle\n"
15682 " this case automatically is to page advance via pladv, but enable\n"
15683 " familying (see plsfam) with a small limit on the file size so that a\n"
15684 " new family member file will be created on each page break.\n"
15685 "\n"
15686 " Redacted form: plbop()\n"
15687 "\n"
15688 " This function is used in examples 2 and 20.\n"
15689 "\n"
15690 "\n"
15691 "\n"
15692 "SYNOPSIS:\n"
15693 "\n"
15694 "plbop()\n"
15695 "\n"
15696 ""},
15697 { "plbox", _wrap_plbox, METH_VARARGS, "\n"
15698 "Draw a box with axes, etc\n"
15699 "\n"
15700 "DESCRIPTION:\n"
15701 "\n"
15702 " Draws a box around the currently defined viewport, and labels it with\n"
15703 " world coordinate values appropriate to the window. Thus plbox should\n"
15704 " only be called after defining both viewport and window. The ascii\n"
15705 " character strings xopt and yopt specify how the box should be drawn as\n"
15706 " described below. If ticks and/or subticks are to be drawn for a\n"
15707 " particular axis, the tick intervals and number of subintervals may be\n"
15708 " specified explicitly, or they may be defaulted by setting the\n"
15709 " appropriate arguments to zero.\n"
15710 "\n"
15711 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15712 "\n"
15713 "\n"
15714 " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15715 " and 29.\n"
15716 "\n"
15717 "\n"
15718 "\n"
15719 "SYNOPSIS:\n"
15720 "\n"
15721 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15722 "\n"
15723 "ARGUMENTS:\n"
15724 "\n"
15725 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15726 " options for the x axis. The string can include any combination of\n"
15727 " the following letters (upper or lower case) in any order: a: Draws\n"
15728 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15729 " (x=0).\n"
15730 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15731 " c: Draws top (X) or right (Y) edge of frame.\n"
15732 " d: Plot labels as date / time. Values are assumed to be\n"
15733 " seconds since the epoch (as used by gmtime).\n"
15734 " f: Always use fixed point numeric labels.\n"
15735 " g: Draws a grid at the major tick interval.\n"
15736 " h: Draws a grid at the minor tick interval.\n"
15737 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15738 " inwards.\n"
15739 " l: Labels axis logarithmically. This only affects the labels,\n"
15740 " not the data, and so it is necessary to compute the logarithms\n"
15741 " of data points before passing them to any of the drawing\n"
15742 " routines.\n"
15743 " m: Writes numeric labels at major tick intervals in the\n"
15744 " unconventional location (above box for X, right of box for Y).\n"
15745 " n: Writes numeric labels at major tick intervals in the\n"
15746 " conventional location (below box for X, left of box for Y).\n"
15747 " o: Use custom labelling function to generate axis label text.\n"
15748 " The custom labelling function can be defined with the\n"
15749 " plslabelfunc command.\n"
15750 " s: Enables subticks between major ticks, only valid if t is\n"
15751 " also specified.\n"
15752 " t: Draws major ticks.\n"
15753 " u: Exactly like \"b\" except don't draw edge line.\n"
15754 " w: Exactly like \"c\" except don't draw edge line.\n"
15755 " x: Exactly like \"t\" (including the side effect of the\n"
15756 " numerical labels for the major ticks) except exclude drawing\n"
15757 " the major and minor tick marks.\n"
15758 "\n"
15759 "\n"
15760 " xtick (PLFLT, input) : World coordinate interval between major\n"
15761 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15762 " generates a suitable tick interval.\n"
15763 "\n"
15764 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15765 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15766 " generates a suitable minor tick interval.\n"
15767 "\n"
15768 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15769 " options for the y axis. The string can include any combination of\n"
15770 " the letters defined above for xopt, and in addition may contain:\n"
15771 " v: Write numeric labels for the y axis parallel to the base of the\n"
15772 " graph, rather than parallel to the axis.\n"
15773 "\n"
15774 "\n"
15775 " ytick (PLFLT, input) : World coordinate interval between major\n"
15776 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15777 " generates a suitable tick interval.\n"
15778 "\n"
15779 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15780 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15781 " generates a suitable minor tick interval.\n"
15782 "\n"
15783 ""},
15784 { "plbox3", _wrap_plbox3, METH_VARARGS, "\n"
15785 "Draw a box with axes, etc, in 3-d\n"
15786 "\n"
15787 "DESCRIPTION:\n"
15788 "\n"
15789 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15790 " plot. For a more complete description of three-dimensional plotting\n"
15791 " see the PLplot documentation.\n"
15792 "\n"
15793 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15794 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15795 "\n"
15796 "\n"
15797 " This function is used in examples 8, 11, 18, and 21.\n"
15798 "\n"
15799 "\n"
15800 "\n"
15801 "SYNOPSIS:\n"
15802 "\n"
15803 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15804 "\n"
15805 "ARGUMENTS:\n"
15806 "\n"
15807 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15808 " options for the x axis. The string can include any combination of\n"
15809 " the following letters (upper or lower case) in any order: b: Draws\n"
15810 " axis at base, at height z=\n"
15811 " zmin where zmin is defined by call to plw3d. This character must be\n"
15812 " specified in order to use any of the other options.\n"
15813 " d: Plot labels as date / time. Values are assumed to be\n"
15814 " seconds since the epoch (as used by gmtime).\n"
15815 " f: Always use fixed point numeric labels.\n"
15816 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15817 " than upwards.\n"
15818 " l: Labels axis logarithmically. This only affects the labels,\n"
15819 " not the data, and so it is necessary to compute the logarithms\n"
15820 " of data points before passing them to any of the drawing\n"
15821 " routines.\n"
15822 " n: Writes numeric labels at major tick intervals.\n"
15823 " o: Use custom labelling function to generate axis label text.\n"
15824 " The custom labelling function can be defined with the\n"
15825 " plslabelfunc command.\n"
15826 " s: Enables subticks between major ticks, only valid if t is\n"
15827 " also specified.\n"
15828 " t: Draws major ticks.\n"
15829 " u: If this is specified, the text label for the axis is\n"
15830 " written under the axis.\n"
15831 "\n"
15832 "\n"
15833 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15834 " the text label for the x axis. It is only drawn if u is in the\n"
15835 " xopt string.\n"
15836 "\n"
15837 " xtick (PLFLT, input) : World coordinate interval between major\n"
15838 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15839 " generates a suitable tick interval.\n"
15840 "\n"
15841 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15842 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15843 " generates a suitable minor tick interval.\n"
15844 "\n"
15845 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15846 " options for the y axis. The string is interpreted in the same way\n"
15847 " as xopt.\n"
15848 "\n"
15849 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15850 " the text label for the y axis. It is only drawn if u is in the\n"
15851 " yopt string.\n"
15852 "\n"
15853 " ytick (PLFLT, input) : World coordinate interval between major\n"
15854 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15855 " generates a suitable tick interval.\n"
15856 "\n"
15857 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15858 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15859 " generates a suitable minor tick interval.\n"
15860 "\n"
15861 " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15862 " options for the z axis. The string can include any combination of\n"
15863 " the following letters (upper or lower case) in any order: b: Draws\n"
15864 " z axis to the left of the surface plot.\n"
15865 " c: Draws z axis to the right of the surface plot.\n"
15866 " d: Draws grid lines parallel to the x-y plane behind the\n"
15867 " figure. These lines are not drawn until after plot3d or\n"
15868 " plmesh are called because of the need for hidden line removal.\n"
15869 " e: Plot labels as date / time. Values are assumed to be\n"
15870 " seconds since the epoch (as used by gmtime). Note this\n"
15871 " suboption is interpreted the same as the d suboption for xopt\n"
15872 " and yopt, but it has to be identified as e for zopt since d\n"
15873 " has already been used for the different purpose above.\n"
15874 " f: Always use fixed point numeric labels.\n"
15875 " i: Inverts tick marks, so they are drawn away from the center.\n"
15876 " l: Labels axis logarithmically. This only affects the labels,\n"
15877 " not the data, and so it is necessary to compute the logarithms\n"
15878 " of data points before passing them to any of the drawing\n"
15879 " routines.\n"
15880 " m: Writes numeric labels at major tick intervals on the\n"
15881 " right-hand z axis.\n"
15882 " n: Writes numeric labels at major tick intervals on the\n"
15883 " left-hand z axis.\n"
15884 " o: Use custom labelling function to generate axis label text.\n"
15885 " The custom labelling function can be defined with the\n"
15886 " plslabelfunc command.\n"
15887 " s: Enables subticks between major ticks, only valid if t is\n"
15888 " also specified.\n"
15889 " t: Draws major ticks.\n"
15890 " u: If this is specified, the text label is written beside the\n"
15891 " left-hand axis.\n"
15892 " v: If this is specified, the text label is written beside the\n"
15893 " right-hand axis.\n"
15894 "\n"
15895 "\n"
15896 " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15897 " the text label for the z axis. It is only drawn if u or v are in\n"
15898 " the zopt string.\n"
15899 "\n"
15900 " ztick (PLFLT, input) : World coordinate interval between major\n"
15901 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15902 " generates a suitable tick interval.\n"
15903 "\n"
15904 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15905 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15906 " generates a suitable minor tick interval.\n"
15907 "\n"
15908 ""},
15909 { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, "\n"
15910 "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15911 "\n"
15912 "DESCRIPTION:\n"
15913 "\n"
15914 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15915 " from relative device coordinates, rx and ry.\n"
15916 "\n"
15917 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15918 "\n"
15919 "\n"
15920 " This function is used in example 31.\n"
15921 "\n"
15922 "\n"
15923 "\n"
15924 "SYNOPSIS:\n"
15925 "\n"
15926 "plcalc_world(rx, ry, wx, wy, window)\n"
15927 "\n"
15928 "ARGUMENTS:\n"
15929 "\n"
15930 " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15931 " the x coordinate.\n"
15932 "\n"
15933 " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15934 " the y coordinate.\n"
15935 "\n"
15936 " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15937 " coordinate corresponding to the relative device coordinates rx and\n"
15938 " ry.\n"
15939 "\n"
15940 " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15941 " coordinate corresponding to the relative device coordinates rx and\n"
15942 " ry.\n"
15943 "\n"
15944 " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15945 " defined window index that corresponds to the input relative device\n"
15946 " coordinates (and the returned world coordinates). To give some\n"
15947 " background on the window index, for each page the initial window\n"
15948 " index is set to zero, and each time plwind is called within the\n"
15949 " page, world and device coordinates are stored for the window and\n"
15950 " the window index is incremented. Thus, for a simple page layout\n"
15951 " with non-overlapping viewports and one window per viewport, window\n"
15952 " corresponds to the viewport index (in the order which the\n"
15953 " viewport/windows were created) of the only viewport/window\n"
15954 " corresponding to rx and ry. However, for more complicated layouts\n"
15955 " with potentially overlapping viewports and possibly more than one\n"
15956 " window (set of world coordinates) per viewport, window and the\n"
15957 " corresponding output world coordinates corresponds to the last\n"
15958 " window created that fulfills the criterion that the relative\n"
15959 " device coordinates are inside it. Finally, in all cases where the\n"
15960 " input relative device coordinates are not inside any\n"
15961 " viewport/window, then the returned value of the last defined\n"
15962 " window index is set to -1.\n"
15963 "\n"
15964 ""},
15965 { "plclear", _wrap_plclear, METH_NOARGS, "\n"
15966 "Clear current (sub)page\n"
15967 "\n"
15968 "DESCRIPTION:\n"
15969 "\n"
15970 " Clears the current page, effectively erasing everything that have been\n"
15971 " drawn. This command only works with interactive drivers; if the\n"
15972 " driver does not support this, the page is filled with the background\n"
15973 " color in use. If the current page is divided into subpages, only the\n"
15974 " current subpage is erased. The nth subpage can be selected with\n"
15975 " pladv(n).\n"
15976 "\n"
15977 " Redacted form: General: plclear()\n"
15978 "\n"
15979 "\n"
15980 " This function is not used in any examples.\n"
15981 "\n"
15982 "\n"
15983 "\n"
15984 "SYNOPSIS:\n"
15985 "\n"
15986 "plclear()\n"
15987 "\n"
15988 ""},
15989 { "plcol0", _wrap_plcol0, METH_O, "\n"
15990 "Set color, cmap0\n"
15991 "\n"
15992 "DESCRIPTION:\n"
15993 "\n"
15994 " Sets the color index for cmap0 (see the PLplot documentation).\n"
15995 "\n"
15996 " Redacted form: plcol0(icol0)\n"
15997 "\n"
15998 " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
15999 "\n"
16000 "\n"
16001 "\n"
16002 "SYNOPSIS:\n"
16003 "\n"
16004 "plcol0(icol0)\n"
16005 "\n"
16006 "ARGUMENTS:\n"
16007 "\n"
16008 " icol0 (PLINT, input) : Integer representing the color. The\n"
16009 " defaults at present are (these may change):\n"
16010 " 0 black (default background)\n"
16011 " 1 red (default foreground)\n"
16012 " 2 yellow\n"
16013 " 3 green\n"
16014 " 4 aquamarine\n"
16015 " 5 pink\n"
16016 " 6 wheat\n"
16017 " 7 grey\n"
16018 " 8 brown\n"
16019 " 9 blue\n"
16020 " 10 BlueViolet\n"
16021 " 11 cyan\n"
16022 " 12 turquoise\n"
16023 " 13 magenta\n"
16024 " 14 salmon\n"
16025 " 15 white\n"
16026 "\n"
16027 " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
16028 " change an individual color in the cmap0 color palette.\n"
16029 "\n"
16030 ""},
16031 { "plcol1", _wrap_plcol1, METH_O, "\n"
16032 "Set color, cmap1\n"
16033 "\n"
16034 "DESCRIPTION:\n"
16035 "\n"
16036 " Sets the color for cmap1 (see the PLplot documentation).\n"
16037 "\n"
16038 " Redacted form: plcol1(col1)\n"
16039 "\n"
16040 " This function is used in examples 12 and 21.\n"
16041 "\n"
16042 "\n"
16043 "\n"
16044 "SYNOPSIS:\n"
16045 "\n"
16046 "plcol1(col1)\n"
16047 "\n"
16048 "ARGUMENTS:\n"
16049 "\n"
16050 " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
16051 " is mapped to color using the continuous cmap1 palette which by\n"
16052 " default ranges from blue to the background color to red. The\n"
16053 " cmap1 palette can also be straightforwardly changed by the user\n"
16054 " with plscmap1 or plscmap1l.\n"
16055 "\n"
16056 ""},
16057 { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, "\n"
16058 "Configure the transformation between continuous and broken-down time for the current stream\n"
16059 "\n"
16060 "DESCRIPTION:\n"
16061 "\n"
16062 " Configure the transformation between continuous and broken-down time\n"
16063 " for the current stream. This transformation is used by both plbtime\n"
16064 " and plctime.\n"
16065 "\n"
16066 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
16067 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16068 "\n"
16069 "\n"
16070 " This function is used in example 29.\n"
16071 "\n"
16072 "\n"
16073 "\n"
16074 "SYNOPSIS:\n"
16075 "\n"
16076 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16077 "\n"
16078 "ARGUMENTS:\n"
16079 "\n"
16080 " scale (PLFLT, input) : The number of days per continuous time unit.\n"
16081 " As a special case, if\n"
16082 " scale is 0., then all other arguments are ignored, and the result (the\n"
16083 " default used by PLplot) is the equivalent of a call to\n"
16084 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
16085 " That is, for this special case broken-down time is calculated with\n"
16086 " the proleptic Gregorian calendar with no leap seconds inserted,\n"
16087 " and the continuous time is defined as the number of seconds since\n"
16088 " the Unix epoch of 1970-01-01T00:00:00Z.\n"
16089 "\n"
16090 " offset1 (PLFLT, input) : If\n"
16091 " ifbtime_offset is true, the parameters\n"
16092 " offset1 and\n"
16093 " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
16094 " (with units in days) specify the epoch of the continuous time\n"
16095 " relative to the MJD epoch corresponding to the Gregorian calendar\n"
16096 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
16097 " are used to specify the origin to allow users (by specifying\n"
16098 " offset1 as an integer that can be exactly represented by a\n"
16099 " floating-point variable and specifying\n"
16100 " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
16101 " the numerical errors of the continuous time representation.\n"
16102 "\n"
16103 " offset2 (PLFLT, input) : See documentation of\n"
16104 " offset1.\n"
16105 "\n"
16106 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
16107 " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
16108 " calendar is used for broken-down time rather than the proleptic\n"
16109 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
16110 " have been historically used to define UTC are inserted into the\n"
16111 " broken-down time. Other possibilities for additional control bits\n"
16112 " for ccontrol exist such as making the historical time corrections\n"
16113 " in the broken-down time corresponding to ET (ephemeris time) or\n"
16114 " making the (slightly non-constant) corrections from international\n"
16115 " atomic time (TAI) to what astronomers define as terrestrial time\n"
16116 " (TT). But those additional possibilities have not been\n"
16117 " implemented yet in the qsastime library (one of the PLplot utility\n"
16118 " libraries).\n"
16119 "\n"
16120 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
16121 " epoch of the continuous time scale is specified by the user. If\n"
16122 " ifbtime_offset is false, then\n"
16123 " offset1 and\n"
16124 " offset2 are used to specify the epoch, and the following broken-down\n"
16125 " time parameters are completely ignored. If\n"
16126 " ifbtime_offset is true, then\n"
16127 " offset1 and\n"
16128 " offset2 are completely ignored, and the following broken-down time\n"
16129 " parameters are used to specify the epoch.\n"
16130 "\n"
16131 " year (PLINT, input) : Year of epoch.\n"
16132 "\n"
16133 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
16134 " 11 (December).\n"
16135 "\n"
16136 " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
16137 "\n"
16138 " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
16139 "\n"
16140 " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
16141 "\n"
16142 " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
16143 "\n"
16144 ""},
16145 { "plcont", _wrap_plcont, METH_VARARGS, "\n"
16146 "Contour plot\n"
16147 "\n"
16148 "DESCRIPTION:\n"
16149 "\n"
16150 " Draws a contour plot of the data in f[\n"
16151 " nx][\n"
16152 " ny], using the nlevel contour levels specified by clevel. Only the\n"
16153 " region of the matrix from kx to lx and from ky to ly is plotted out\n"
16154 " where all these index ranges are interpreted as one-based for\n"
16155 " historical reasons. A transformation routine pointed to by pltr with\n"
16156 " a generic pointer pltr_data for additional data required by the\n"
16157 " transformation routine is used to map indices within the matrix to the\n"
16158 " world coordinates.\n"
16159 "\n"
16160 " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16161 " where (see above discussion) the pltr, pltr_data callback arguments\n"
16162 " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
16163 " vectors; or xg and yg matrices.\n"
16164 "\n"
16165 " This function is used in examples 9, 14, 16, and 22.\n"
16166 "\n"
16167 "\n"
16168 "\n"
16169 "SYNOPSIS:\n"
16170 "\n"
16171 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16172 "\n"
16173 "ARGUMENTS:\n"
16174 "\n"
16175 " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
16176 "\n"
16177 " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
16178 "\n"
16179 " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
16180 " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
16181 " zero-based for historical backwards-compatibility reasons.\n"
16182 "\n"
16183 " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
16184 " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
16185 " zero-based for historical backwards-compatibility reasons.\n"
16186 "\n"
16187 " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
16188 " which to draw contours.\n"
16189 "\n"
16190 " nlevel (PLINT, input) : Number of contour levels to draw.\n"
16191 "\n"
16192 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
16193 " defines the transformation between the zero-based indices of the\n"
16194 " matrix f and the world coordinates.For the C case, transformation\n"
16195 " functions are provided in the PLplot library: pltr0 for the\n"
16196 " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
16197 " respectively defined by vectors and matrices. In addition, C\n"
16198 " callback routines for the transformation can be supplied by the\n"
16199 " user such as the mypltr function in examples/c/x09c.c which\n"
16200 " provides a general linear transformation between index coordinates\n"
16201 " and world coordinates.For languages other than C you should\n"
16202 " consult the PLplot documentation for the details concerning how\n"
16203 " PLTRANSFORM_callback arguments are interfaced. However, in\n"
16204 " general, a particular pattern of callback-associated arguments\n"
16205 " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
16206 " yg matrices are respectively interfaced to a linear-transformation\n"
16207 " routine similar to the above mypltr function; pltr1; and pltr2.\n"
16208 " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
16209 " the PLplot documentation) support native language callbacks for\n"
16210 " handling index to world-coordinate transformations. Examples of\n"
16211 " these various approaches are given in examples/<language>x09*,\n"
16212 " examples/<language>x16*, examples/<language>x20*,\n"
16213 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
16214 " supported languages.\n"
16215 "\n"
16216 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
16217 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
16218 " that is externally supplied.\n"
16219 "\n"
16220 ""},
16221 { "plctime", _wrap_plctime, METH_VARARGS, "\n"
16222 "Calculate continuous time from broken-down time for the current stream\n"
16223 "\n"
16224 "DESCRIPTION:\n"
16225 "\n"
16226 " Calculate continuous time, ctime, from broken-down time for the\n"
16227 " current stream. The broken-down\n"
16228 " time is specified by the following parameters: year, month, day, hour,\n"
16229 " min, and sec. This function is the inverse of plbtime.\n"
16230 "\n"
16231 " The PLplot definition of broken-down time is a calendar time that\n"
16232 " completely ignores all time zone offsets, i.e., it is the user's\n"
16233 " responsibility to apply those offsets (if so desired) before using the\n"
16234 " PLplot time API. By default broken-down time is defined using the\n"
16235 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16236 " continuous time is defined as the number of seconds since the Unix\n"
16237 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16238 " broken-down and continuous time are possible, see plconfigtime which\n"
16239 " specifies that transformation for the current stream.\n"
16240 "\n"
16241 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16242 " ctime)\n"
16243 "\n"
16244 "\n"
16245 " This function is used in example 29.\n"
16246 "\n"
16247 "\n"
16248 "\n"
16249 "SYNOPSIS:\n"
16250 "\n"
16251 "plctime(year, month, day, hour, min, sec, ctime)\n"
16252 "\n"
16253 "ARGUMENTS:\n"
16254 "\n"
16255 " year (PLINT, input) : Input year.\n"
16256 "\n"
16257 " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16258 " (December).\n"
16259 "\n"
16260 " day (PLINT, input) : Input day in range from 1 to 31.\n"
16261 "\n"
16262 " hour (PLINT, input) : Input hour in range from 0 to 23\n"
16263 "\n"
16264 " min (PLINT, input) : Input minute in range from 0 to 59.\n"
16265 "\n"
16266 " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
16267 "\n"
16268 " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
16269 " time calculated from the broken-down time specified by the\n"
16270 " previous parameters.\n"
16271 "\n"
16272 ""},
16273 { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, "\n"
16274 "Copy state parameters from the reference stream to the current stream\n"
16275 "\n"
16276 "DESCRIPTION:\n"
16277 "\n"
16278 " Copies state parameters from the reference stream to the current\n"
16279 " stream. Tell driver interface to map device coordinates unless flags\n"
16280 " == 1.\n"
16281 "\n"
16282 " This function is used for making save files of selected plots (e.g.\n"
16283 " from the TK driver). After initializing, you can get a copy of the\n"
16284 " current plot to the specified device by switching to this stream and\n"
16285 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16286 " appropriate. The plot buffer must have previously been enabled (done\n"
16287 " automatically by some display drivers, such as X).\n"
16288 "\n"
16289 " Redacted form: plcpstrm(iplsr, flags)\n"
16290 "\n"
16291 " This function is used in example 1,20.\n"
16292 "\n"
16293 "\n"
16294 "\n"
16295 "SYNOPSIS:\n"
16296 "\n"
16297 "plcpstrm(iplsr, flags)\n"
16298 "\n"
16299 "ARGUMENTS:\n"
16300 "\n"
16301 " iplsr (PLINT, input) : Number of reference stream.\n"
16302 "\n"
16303 " flags (PLBOOL, input) : If flags is set to true the device\n"
16304 " coordinates are not copied from the reference to current stream.\n"
16305 "\n"
16306 ""},
16307 { "plend", _wrap_plend, METH_NOARGS, "\n"
16308 "End plotting session\n"
16309 "\n"
16310 "DESCRIPTION:\n"
16311 "\n"
16312 " Ends a plotting session, tidies up all the output files, switches\n"
16313 " interactive devices back into text mode and frees up any memory that\n"
16314 " was allocated. Must be called before end of program.\n"
16315 "\n"
16316 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16317 " wait state after a call to plend or other functions which trigger the\n"
16318 " end of a plot page. To avoid this, use the plspause function.\n"
16319 "\n"
16320 " Redacted form: plend()\n"
16321 "\n"
16322 " This function is used in all of the examples.\n"
16323 "\n"
16324 "\n"
16325 "\n"
16326 "SYNOPSIS:\n"
16327 "\n"
16328 "plend()\n"
16329 "\n"
16330 ""},
16331 { "plend1", _wrap_plend1, METH_NOARGS, "\n"
16332 "End plotting session for current stream\n"
16333 "\n"
16334 "DESCRIPTION:\n"
16335 "\n"
16336 " Ends a plotting session for the current output stream only. See\n"
16337 " plsstrm for more info.\n"
16338 "\n"
16339 " Redacted form: plend1()\n"
16340 "\n"
16341 " This function is used in examples 1 and 20.\n"
16342 "\n"
16343 "\n"
16344 "\n"
16345 "SYNOPSIS:\n"
16346 "\n"
16347 "plend1()\n"
16348 "\n"
16349 ""},
16350 { "plenv", _wrap_plenv, METH_VARARGS, "\n"
16351 "Set up standard window and draw box\n"
16352 "\n"
16353 "DESCRIPTION:\n"
16354 "\n"
16355 " Sets up plotter environment for simple graphs by calling pladv and\n"
16356 " setting up viewport and window to sensible default values. plenv\n"
16357 " leaves a standard margin (left-hand margin of eight character heights,\n"
16358 " and a margin around the other three sides of five character heights)\n"
16359 " around most graphs for axis labels and a title. When these defaults\n"
16360 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16361 " plvasp for setting up the viewport, plwind for defining the window,\n"
16362 " and plbox for drawing the box.\n"
16363 "\n"
16364 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16365 "\n"
16366 " This function is used in example 1,3,9,13,14,19-22,29.\n"
16367 "\n"
16368 "\n"
16369 "\n"
16370 "SYNOPSIS:\n"
16371 "\n"
16372 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16373 "\n"
16374 "ARGUMENTS:\n"
16375 "\n"
16376 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16377 " world coordinates).\n"
16378 "\n"
16379 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16380 " world coordinates).\n"
16381 "\n"
16382 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16383 " coordinates).\n"
16384 "\n"
16385 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16386 " coordinates).\n"
16387 "\n"
16388 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16389 " scales will not be set, the user must set up the scale before\n"
16390 " calling plenv using plsvpa, plvasp or other.\n"
16391 " 0: the x and y axes are scaled independently to use as much of\n"
16392 " the screen as possible.\n"
16393 " 1: the scales of the x and y axes are made equal.\n"
16394 " 2: the axis of the x and y axes are made equal, and the plot\n"
16395 " box will be square.\n"
16396 "\n"
16397 "\n"
16398 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16399 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16400 " -1: draw box only.\n"
16401 " 0: draw box, ticks, and numeric tick labels.\n"
16402 " 1: also draw coordinate axes at x=0 and y=0.\n"
16403 " 2: also draw a grid at major tick positions in both\n"
16404 " coordinates.\n"
16405 " 3: also draw a grid at minor tick positions in both\n"
16406 " coordinates.\n"
16407 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16408 " have to be converted to logarithms separately.)\n"
16409 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16410 " have to be converted to logarithms separately.)\n"
16411 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16412 " have to be converted to logarithms separately.)\n"
16413 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16414 " have to be converted to logarithms separately.)\n"
16415 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16416 " have to be converted to logarithms separately.)\n"
16417 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16418 " have to be converted to logarithms separately.)\n"
16419 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16420 " have to be converted to logarithms separately.)\n"
16421 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16422 " have to be converted to logarithms separately.)\n"
16423 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16424 " and y data have to be converted to logarithms separately.)\n"
16425 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16426 " and y data have to be converted to logarithms separately.)\n"
16427 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16428 " and y data have to be converted to logarithms separately.)\n"
16429 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16430 " and y data have to be converted to logarithms separately.)\n"
16431 " 40: same as 0 except date / time x labels.\n"
16432 " 41: same as 1 except date / time x labels.\n"
16433 " 42: same as 2 except date / time x labels.\n"
16434 " 43: same as 3 except date / time x labels.\n"
16435 " 50: same as 0 except date / time y labels.\n"
16436 " 51: same as 1 except date / time y labels.\n"
16437 " 52: same as 2 except date / time y labels.\n"
16438 " 53: same as 3 except date / time y labels.\n"
16439 " 60: same as 0 except date / time x and y labels.\n"
16440 " 61: same as 1 except date / time x and y labels.\n"
16441 " 62: same as 2 except date / time x and y labels.\n"
16442 " 63: same as 3 except date / time x and y labels.\n"
16443 " 70: same as 0 except custom x and y labels.\n"
16444 " 71: same as 1 except custom x and y labels.\n"
16445 " 72: same as 2 except custom x and y labels.\n"
16446 " 73: same as 3 except custom x and y labels.\n"
16447 "\n"
16448 ""},
16449 { "plenv0", _wrap_plenv0, METH_VARARGS, "\n"
16450 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16451 "\n"
16452 "DESCRIPTION:\n"
16453 "\n"
16454 " Sets up plotter environment for simple graphs by calling pladv and\n"
16455 " setting up viewport and window to sensible default values. plenv0\n"
16456 " leaves a standard margin (left-hand margin of eight character heights,\n"
16457 " and a margin around the other three sides of five character heights)\n"
16458 " around most graphs for axis labels and a title. When these defaults\n"
16459 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16460 " plvasp for setting up the viewport, plwind for defining the window,\n"
16461 " and plbox for drawing the box.\n"
16462 "\n"
16463 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16464 "\n"
16465 " This function is used in example 21.\n"
16466 "\n"
16467 "\n"
16468 "\n"
16469 "SYNOPSIS:\n"
16470 "\n"
16471 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16472 "\n"
16473 "ARGUMENTS:\n"
16474 "\n"
16475 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16476 " world coordinates).\n"
16477 "\n"
16478 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16479 " world coordinates).\n"
16480 "\n"
16481 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16482 " coordinates).\n"
16483 "\n"
16484 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16485 " coordinates).\n"
16486 "\n"
16487 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16488 " scales will not be set, the user must set up the scale before\n"
16489 " calling plenv0 using plsvpa, plvasp or other.\n"
16490 " 0: the x and y axes are scaled independently to use as much of\n"
16491 " the screen as possible.\n"
16492 " 1: the scales of the x and y axes are made equal.\n"
16493 " 2: the axis of the x and y axes are made equal, and the plot\n"
16494 " box will be square.\n"
16495 "\n"
16496 "\n"
16497 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16498 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16499 " -1: draw box only.\n"
16500 " 0: draw box, ticks, and numeric tick labels.\n"
16501 " 1: also draw coordinate axes at x=0 and y=0.\n"
16502 " 2: also draw a grid at major tick positions in both\n"
16503 " coordinates.\n"
16504 " 3: also draw a grid at minor tick positions in both\n"
16505 " coordinates.\n"
16506 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16507 " have to be converted to logarithms separately.)\n"
16508 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16509 " have to be converted to logarithms separately.)\n"
16510 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16511 " have to be converted to logarithms separately.)\n"
16512 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16513 " have to be converted to logarithms separately.)\n"
16514 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16515 " have to be converted to logarithms separately.)\n"
16516 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16517 " have to be converted to logarithms separately.)\n"
16518 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16519 " have to be converted to logarithms separately.)\n"
16520 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16521 " have to be converted to logarithms separately.)\n"
16522 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16523 " and y data have to be converted to logarithms separately.)\n"
16524 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16525 " and y data have to be converted to logarithms separately.)\n"
16526 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16527 " and y data have to be converted to logarithms separately.)\n"
16528 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16529 " and y data have to be converted to logarithms separately.)\n"
16530 " 40: same as 0 except date / time x labels.\n"
16531 " 41: same as 1 except date / time x labels.\n"
16532 " 42: same as 2 except date / time x labels.\n"
16533 " 43: same as 3 except date / time x labels.\n"
16534 " 50: same as 0 except date / time y labels.\n"
16535 " 51: same as 1 except date / time y labels.\n"
16536 " 52: same as 2 except date / time y labels.\n"
16537 " 53: same as 3 except date / time y labels.\n"
16538 " 60: same as 0 except date / time x and y labels.\n"
16539 " 61: same as 1 except date / time x and y labels.\n"
16540 " 62: same as 2 except date / time x and y labels.\n"
16541 " 63: same as 3 except date / time x and y labels.\n"
16542 " 70: same as 0 except custom x and y labels.\n"
16543 " 71: same as 1 except custom x and y labels.\n"
16544 " 72: same as 2 except custom x and y labels.\n"
16545 " 73: same as 3 except custom x and y labels.\n"
16546 "\n"
16547 ""},
16548 { "pleop", _wrap_pleop, METH_NOARGS, "\n"
16549 "Eject current page\n"
16550 "\n"
16551 "DESCRIPTION:\n"
16552 "\n"
16553 " Clears the graphics screen of an interactive device, or ejects a page\n"
16554 " on a plotter. See plbop for more information.\n"
16555 "\n"
16556 " Redacted form: pleop()\n"
16557 "\n"
16558 " This function is used in example 2,14.\n"
16559 "\n"
16560 "\n"
16561 "\n"
16562 "SYNOPSIS:\n"
16563 "\n"
16564 "pleop()\n"
16565 "\n"
16566 ""},
16567 { "plerrx", _wrap_plerrx, METH_VARARGS, "\n"
16568 "Draw error bars in x direction\n"
16569 "\n"
16570 "DESCRIPTION:\n"
16571 "\n"
16572 " Draws a set of n error bars in x direction, the i'th error bar\n"
16573 " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16574 " of the error bars are of length equal to the minor tick length\n"
16575 " (settable using plsmin).\n"
16576 "\n"
16577 " Redacted form: General: plerrx(xmin, ymax, y)\n"
16578 "\n"
16579 "\n"
16580 " This function is used in example 29.\n"
16581 "\n"
16582 "\n"
16583 "\n"
16584 "SYNOPSIS:\n"
16585 "\n"
16586 "plerrx(n, xmin, xmax, y)\n"
16587 "\n"
16588 "ARGUMENTS:\n"
16589 "\n"
16590 " n (PLINT, input) : Number of error bars to draw.\n"
16591 "\n"
16592 " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16593 " of the left-hand endpoints of the error bars.\n"
16594 "\n"
16595 " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16596 " of the right-hand endpoints of the error bars.\n"
16597 "\n"
16598 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16599 " the error bars.\n"
16600 "\n"
16601 ""},
16602 { "plerry", _wrap_plerry, METH_VARARGS, "\n"
16603 "Draw error bars in the y direction\n"
16604 "\n"
16605 "DESCRIPTION:\n"
16606 "\n"
16607 " Draws a set of n error bars in the y direction, the i'th error bar\n"
16608 " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16609 " of the error bars are of length equal to the minor tick length\n"
16610 " (settable using plsmin).\n"
16611 "\n"
16612 " Redacted form: General: plerry(x, ymin, ymax)\n"
16613 "\n"
16614 "\n"
16615 " This function is used in example 29.\n"
16616 "\n"
16617 "\n"
16618 "\n"
16619 "SYNOPSIS:\n"
16620 "\n"
16621 "plerry(n, x, ymin, ymax)\n"
16622 "\n"
16623 "ARGUMENTS:\n"
16624 "\n"
16625 " n (PLINT, input) : Number of error bars to draw.\n"
16626 "\n"
16627 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16628 " the error bars.\n"
16629 "\n"
16630 " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16631 " of the lower endpoints of the error bars.\n"
16632 "\n"
16633 " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16634 " of the upper endpoints of the error bars.\n"
16635 "\n"
16636 ""},
16637 { "plfamadv", _wrap_plfamadv, METH_NOARGS, "\n"
16638 "Advance to the next family file on the next new page\n"
16639 "\n"
16640 "DESCRIPTION:\n"
16641 "\n"
16642 " Advance to the next family file on the next new page.\n"
16643 "\n"
16644 " Redacted form: plfamadv()\n"
16645 "\n"
16646 " This function is not used in any examples.\n"
16647 "\n"
16648 "\n"
16649 "\n"
16650 "SYNOPSIS:\n"
16651 "\n"
16652 "plfamadv()\n"
16653 "\n"
16654 ""},
16655 { "plfill", _wrap_plfill, METH_VARARGS, "\n"
16656 "Draw filled polygon\n"
16657 "\n"
16658 "DESCRIPTION:\n"
16659 "\n"
16660 " Fills the polygon defined by the n points (\n"
16661 " x[i],\n"
16662 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16663 " style is a solid fill. The routine will automatically close the\n"
16664 " polygon between the last and first vertices. If multiple closed\n"
16665 " polygons are passed in x and y then plfill will fill in between them.\n"
16666 "\n"
16667 " Redacted form: plfill(x,y)\n"
16668 "\n"
16669 " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16670 "\n"
16671 "\n"
16672 "\n"
16673 "SYNOPSIS:\n"
16674 "\n"
16675 "plfill(n, x, y)\n"
16676 "\n"
16677 "ARGUMENTS:\n"
16678 "\n"
16679 " n (PLINT, input) : Number of vertices in polygon.\n"
16680 "\n"
16681 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16682 " vertices.\n"
16683 "\n"
16684 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16685 " vertices.\n"
16686 "\n"
16687 ""},
16688 { "plfill3", _wrap_plfill3, METH_VARARGS, "\n"
16689 "Draw filled polygon in 3D\n"
16690 "\n"
16691 "DESCRIPTION:\n"
16692 "\n"
16693 " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16694 " vectors using the pattern defined by plpsty or plpat. The routine\n"
16695 " will automatically close the polygon between the last and first\n"
16696 " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16697 " plfill3 will fill in between them.\n"
16698 "\n"
16699 " Redacted form: General: plfill3(x, y, z)\n"
16700 "\n"
16701 "\n"
16702 " This function is used in example 15.\n"
16703 "\n"
16704 "\n"
16705 "\n"
16706 "SYNOPSIS:\n"
16707 "\n"
16708 "plfill3(n, x, y, z)\n"
16709 "\n"
16710 "ARGUMENTS:\n"
16711 "\n"
16712 " n (PLINT, input) : Number of vertices in polygon.\n"
16713 "\n"
16714 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16715 " vertices.\n"
16716 "\n"
16717 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16718 " vertices.\n"
16719 "\n"
16720 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16721 " vertices.\n"
16722 "\n"
16723 ""},
16724 { "plgradient", _wrap_plgradient, METH_VARARGS, "\n"
16725 "Draw linear gradient inside polygon\n"
16726 "\n"
16727 "DESCRIPTION:\n"
16728 "\n"
16729 " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16730 " points (\n"
16731 " x[i],\n"
16732 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16733 " polygon coordinates and the gradient angle are all expressed in world\n"
16734 " coordinates. The angle from the x axis for both the rotated\n"
16735 " coordinate system and the gradient vector is specified by angle. The\n"
16736 " magnitude of the gradient vector is the difference between the maximum\n"
16737 " and minimum values of x for the vertices in the rotated coordinate\n"
16738 " system. The origin of the gradient vector can be interpreted as being\n"
16739 " anywhere on the line corresponding to the minimum x value for the\n"
16740 " vertices in the rotated coordinate system. The distance along the\n"
16741 " gradient vector is linearly transformed to the independent variable of\n"
16742 " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16743 " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16744 " color corresponding to the independent variable of cmap1. For more\n"
16745 " information about cmap1 (see the PLplot documentation).\n"
16746 "\n"
16747 " Redacted form: plgradient(x,y,angle)\n"
16748 "\n"
16749 " This function is used in examples 25 and 30.\n"
16750 "\n"
16751 "\n"
16752 "\n"
16753 "SYNOPSIS:\n"
16754 "\n"
16755 "plgradient(n, x, y, angle)\n"
16756 "\n"
16757 "ARGUMENTS:\n"
16758 "\n"
16759 " n (PLINT, input) : Number of vertices in polygon.\n"
16760 "\n"
16761 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16762 " vertices.\n"
16763 "\n"
16764 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16765 " vertices.\n"
16766 "\n"
16767 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16768 " axis.\n"
16769 "\n"
16770 ""},
16771 { "plflush", _wrap_plflush, METH_NOARGS, "\n"
16772 "Flushes the output stream\n"
16773 "\n"
16774 "DESCRIPTION:\n"
16775 "\n"
16776 " Flushes the output stream. Use sparingly, if at all.\n"
16777 "\n"
16778 " Redacted form: plflush()\n"
16779 "\n"
16780 " This function is used in examples 1 and 14.\n"
16781 "\n"
16782 "\n"
16783 "\n"
16784 "SYNOPSIS:\n"
16785 "\n"
16786 "plflush()\n"
16787 "\n"
16788 ""},
16789 { "plfont", _wrap_plfont, METH_O, "\n"
16790 "Set font\n"
16791 "\n"
16792 "DESCRIPTION:\n"
16793 "\n"
16794 " Sets the font used for subsequent text and symbols. For devices that\n"
16795 " still use Hershey fonts this routine has no effect unless the Hershey\n"
16796 " fonts with extended character set are loaded (see plfontld). For\n"
16797 " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16798 " this routine calls the plsfci routine with argument set up\n"
16799 " appropriately for the various cases below. However, this method of\n"
16800 " specifying the font for unicode-aware devices is deprecated, and the\n"
16801 " much more flexible method of calling plsfont directly is recommended\n"
16802 " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16803 "\n"
16804 " Redacted form: plfont(ifont)\n"
16805 "\n"
16806 " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16807 "\n"
16808 "\n"
16809 "\n"
16810 "SYNOPSIS:\n"
16811 "\n"
16812 "plfont(ifont)\n"
16813 "\n"
16814 "ARGUMENTS:\n"
16815 "\n"
16816 " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16817 " (simplest and fastest)\n"
16818 " 2: Serif font\n"
16819 " 3: Italic font\n"
16820 " 4: Script font\n"
16821 "\n"
16822 ""},
16823 { "plfontld", _wrap_plfontld, METH_O, "\n"
16824 "Load Hershey fonts\n"
16825 "\n"
16826 "DESCRIPTION:\n"
16827 "\n"
16828 " Loads the Hershey fonts used for text and symbols. This routine may\n"
16829 " be called before or after initializing PLplot. If not explicitly\n"
16830 " called before PLplot initialization, then by default that\n"
16831 " initialization loads Hershey fonts with the extended character set.\n"
16832 " This routine only has a practical effect for devices that still use\n"
16833 " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16834 " system fonts instead of Hershey fonts).\n"
16835 "\n"
16836 " Redacted form: plfontld(fnt)\n"
16837 "\n"
16838 " This function is used in examples 1 and 7.\n"
16839 "\n"
16840 "\n"
16841 "\n"
16842 "SYNOPSIS:\n"
16843 "\n"
16844 "plfontld(fnt)\n"
16845 "\n"
16846 "ARGUMENTS:\n"
16847 "\n"
16848 " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16849 " A zero value specifies Hershey fonts with the standard character\n"
16850 " set and a non-zero value (the default assumed if plfontld is never\n"
16851 " called) specifies Hershey fonts with the extended character set.\n"
16852 "\n"
16853 ""},
16854 { "plgchr", _wrap_plgchr, METH_NOARGS, "\n"
16855 "Get character default height and current (scaled) height\n"
16856 "\n"
16857 "DESCRIPTION:\n"
16858 "\n"
16859 " Get character default height and current (scaled) height.\n"
16860 "\n"
16861 " Redacted form: plgchr(p_def, p_ht)\n"
16862 "\n"
16863 " This function is used in example 23.\n"
16864 "\n"
16865 "\n"
16866 "\n"
16867 "SYNOPSIS:\n"
16868 "\n"
16869 "plgchr(p_def, p_ht)\n"
16870 "\n"
16871 "ARGUMENTS:\n"
16872 "\n"
16873 " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16874 " character height (mm).\n"
16875 "\n"
16876 " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16877 " character height (mm).\n"
16878 "\n"
16879 ""},
16880 { "plgcol0", _wrap_plgcol0, METH_O, "\n"
16881 "Returns 8-bit RGB values for given color index from cmap0\n"
16882 "\n"
16883 "DESCRIPTION:\n"
16884 "\n"
16885 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16886 " PLplot documentation). Values are negative if an invalid color id is\n"
16887 " given.\n"
16888 "\n"
16889 " Redacted form: plgcol0(icol0, r, g, b)\n"
16890 "\n"
16891 " This function is used in example 2.\n"
16892 "\n"
16893 "\n"
16894 "\n"
16895 "SYNOPSIS:\n"
16896 "\n"
16897 "plgcol0(icol0, r, g, b)\n"
16898 "\n"
16899 "ARGUMENTS:\n"
16900 "\n"
16901 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16902 "\n"
16903 " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16904 " value.\n"
16905 "\n"
16906 " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16907 " value.\n"
16908 "\n"
16909 " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16910 " value.\n"
16911 "\n"
16912 ""},
16913 { "plgcol0a", _wrap_plgcol0a, METH_O, "\n"
16914 "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16915 "\n"
16916 "DESCRIPTION:\n"
16917 "\n"
16918 " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16919 " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16920 " Values are negative if an invalid color id is given.\n"
16921 "\n"
16922 " Redacted form: plgcola(r, g, b)\n"
16923 "\n"
16924 " This function is used in example 30.\n"
16925 "\n"
16926 "\n"
16927 "\n"
16928 "SYNOPSIS:\n"
16929 "\n"
16930 "plgcol0a(icol0, r, g, b, alpha)\n"
16931 "\n"
16932 "ARGUMENTS:\n"
16933 "\n"
16934 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16935 "\n"
16936 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16937 " in the range from 0 to 255.\n"
16938 "\n"
16939 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16940 " in the range from 0 to 255.\n"
16941 "\n"
16942 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16943 " in the range from 0 to 255.\n"
16944 "\n"
16945 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16946 " transparency in the range from (0.0-1.0).\n"
16947 "\n"
16948 ""},
16949 { "plgcolbg", _wrap_plgcolbg, METH_NOARGS, "\n"
16950 "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16951 "\n"
16952 "DESCRIPTION:\n"
16953 "\n"
16954 " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16955 "\n"
16956 " Redacted form: plgcolbg(r, g, b)\n"
16957 "\n"
16958 " This function is used in example 31.\n"
16959 "\n"
16960 "\n"
16961 "\n"
16962 "SYNOPSIS:\n"
16963 "\n"
16964 "plgcolbg(r, g, b)\n"
16965 "\n"
16966 "ARGUMENTS:\n"
16967 "\n"
16968 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16969 " in the range from 0 to 255.\n"
16970 "\n"
16971 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16972 " in the range from 0 to 255.\n"
16973 "\n"
16974 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16975 " in the range from 0 to 255.\n"
16976 "\n"
16977 ""},
16978 { "plgcolbga", _wrap_plgcolbga, METH_NOARGS, "\n"
16979 "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
16980 "\n"
16981 "DESCRIPTION:\n"
16982 "\n"
16983 " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
16984 " alpha transparency value.\n"
16985 "\n"
16986 " This function is used in example 31.\n"
16987 "\n"
16988 "\n"
16989 "\n"
16990 "SYNOPSIS:\n"
16991 "\n"
16992 "plgcolbga(r, g, b, alpha)\n"
16993 "\n"
16994 "ARGUMENTS:\n"
16995 "\n"
16996 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16997 " in the range from 0 to 255.\n"
16998 "\n"
16999 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
17000 " in the range from 0 to 255.\n"
17001 "\n"
17002 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17003 " in the range from 0 to 255.\n"
17004 "\n"
17005 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
17006 " transparency in the range (0.0-1.0).\n"
17007 "\n"
17008 ""},
17009 { "plgcompression", _wrap_plgcompression, METH_NOARGS, "\n"
17010 "Get the current device-compression setting\n"
17011 "\n"
17012 "DESCRIPTION:\n"
17013 "\n"
17014 " Get the current device-compression setting. This parameter is only\n"
17015 " used for drivers that provide compression.\n"
17016 "\n"
17017 " Redacted form: plgcompression(compression)\n"
17018 "\n"
17019 " This function is used in example 31.\n"
17020 "\n"
17021 "\n"
17022 "\n"
17023 "SYNOPSIS:\n"
17024 "\n"
17025 "plgcompression(compression)\n"
17026 "\n"
17027 "ARGUMENTS:\n"
17028 "\n"
17029 " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
17030 " compression setting for the current device.\n"
17031 "\n"
17032 ""},
17033 { "plgdev", _wrap_plgdev, METH_NOARGS, "\n"
17034 "Get the current device (keyword) name\n"
17035 "\n"
17036 "DESCRIPTION:\n"
17037 "\n"
17038 " Get the current device (keyword) name. Note: you must have allocated\n"
17039 " space for this (80 characters is safe).\n"
17040 "\n"
17041 " Redacted form: plgdev(p_dev)\n"
17042 "\n"
17043 " This function is used in example 14.\n"
17044 "\n"
17045 "\n"
17046 "\n"
17047 "SYNOPSIS:\n"
17048 "\n"
17049 "plgdev(p_dev)\n"
17050 "\n"
17051 "ARGUMENTS:\n"
17052 "\n"
17053 " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17054 " (with preallocated length of 80 characters or more) containing the\n"
17055 " device (keyword) name.\n"
17056 "\n"
17057 ""},
17058 { "plgdidev", _wrap_plgdidev, METH_NOARGS, "\n"
17059 "Get parameters that define current device-space window\n"
17060 "\n"
17061 "DESCRIPTION:\n"
17062 "\n"
17063 " Get relative margin width, aspect ratio, and relative justification\n"
17064 " that define current device-space window. If plsdidev has not been\n"
17065 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
17066 " p_jy will all be 0.\n"
17067 "\n"
17068 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17069 "\n"
17070 " This function is used in example 31.\n"
17071 "\n"
17072 "\n"
17073 "\n"
17074 "SYNOPSIS:\n"
17075 "\n"
17076 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17077 "\n"
17078 "ARGUMENTS:\n"
17079 "\n"
17080 " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17081 " margin width.\n"
17082 "\n"
17083 " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
17084 " ratio.\n"
17085 "\n"
17086 " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17087 " justification in x.\n"
17088 "\n"
17089 " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17090 " justification in y.\n"
17091 "\n"
17092 ""},
17093 { "plgdiori", _wrap_plgdiori, METH_NOARGS, "\n"
17094 "Get plot orientation\n"
17095 "\n"
17096 "DESCRIPTION:\n"
17097 "\n"
17098 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
17099 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
17100 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
17101 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
17102 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
17103 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
17104 " not been called the default value pointed to by p_rot will be 0.\n"
17105 "\n"
17106 " Redacted form: plgdiori(p_rot)\n"
17107 "\n"
17108 " This function is not used in any examples.\n"
17109 "\n"
17110 "\n"
17111 "\n"
17112 "SYNOPSIS:\n"
17113 "\n"
17114 "plgdiori(p_rot)\n"
17115 "\n"
17116 "ARGUMENTS:\n"
17117 "\n"
17118 " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
17119 " parameter.\n"
17120 "\n"
17121 ""},
17122 { "plgdiplt", _wrap_plgdiplt, METH_NOARGS, "\n"
17123 "Get parameters that define current plot-space window\n"
17124 "\n"
17125 "DESCRIPTION:\n"
17126 "\n"
17127 " Get relative minima and maxima that define current plot-space window.\n"
17128 " If plsdiplt has not been called the default values pointed to by\n"
17129 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
17130 "\n"
17131 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17132 "\n"
17133 " This function is used in example 31.\n"
17134 "\n"
17135 "\n"
17136 "\n"
17137 "SYNOPSIS:\n"
17138 "\n"
17139 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17140 "\n"
17141 "ARGUMENTS:\n"
17142 "\n"
17143 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17144 " minimum in x.\n"
17145 "\n"
17146 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17147 " minimum in y.\n"
17148 "\n"
17149 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17150 " maximum in x.\n"
17151 "\n"
17152 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17153 " maximum in y.\n"
17154 "\n"
17155 ""},
17156 { "plgfam", _wrap_plgfam, METH_NOARGS, "\n"
17157 "Get family file parameters\n"
17158 "\n"
17159 "DESCRIPTION:\n"
17160 "\n"
17161 " Gets information about current family file, if familying is enabled.\n"
17162 " See the PLplot documentation for more information.\n"
17163 "\n"
17164 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
17165 "\n"
17166 " This function is used in examples 14 and 31.\n"
17167 "\n"
17168 "\n"
17169 "\n"
17170 "SYNOPSIS:\n"
17171 "\n"
17172 "plgfam(p_fam, p_num, p_bmax)\n"
17173 "\n"
17174 "ARGUMENTS:\n"
17175 "\n"
17176 " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17177 " family flag value. If nonzero, familying is enabled for the\n"
17178 " current device.\n"
17179 "\n"
17180 " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17181 " family file number.\n"
17182 "\n"
17183 " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17184 " file size (in bytes) for a family file.\n"
17185 "\n"
17186 ""},
17187 { "plgfci", _wrap_plgfci, METH_NOARGS, "\n"
17188 "Get FCI (font characterization integer)\n"
17189 "\n"
17190 "DESCRIPTION:\n"
17191 "\n"
17192 " Gets information about the current font using the FCI approach. See\n"
17193 " the PLplot documentation for more information.\n"
17194 "\n"
17195 " Redacted form: plgfci(p_fci)\n"
17196 "\n"
17197 " This function is used in example 23.\n"
17198 "\n"
17199 "\n"
17200 "\n"
17201 "SYNOPSIS:\n"
17202 "\n"
17203 "plgfci(p_fci)\n"
17204 "\n"
17205 "ARGUMENTS:\n"
17206 "\n"
17207 " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
17208 " FCI value.\n"
17209 "\n"
17210 ""},
17211 { "plgfnam", _wrap_plgfnam, METH_NOARGS, "\n"
17212 "Get output file name\n"
17213 "\n"
17214 "DESCRIPTION:\n"
17215 "\n"
17216 " Gets the current output file name, if applicable.\n"
17217 "\n"
17218 " Redacted form: plgfnam(fnam)\n"
17219 "\n"
17220 " This function is used in example 31.\n"
17221 "\n"
17222 "\n"
17223 "\n"
17224 "SYNOPSIS:\n"
17225 "\n"
17226 "plgfnam(fnam)\n"
17227 "\n"
17228 "ARGUMENTS:\n"
17229 "\n"
17230 " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17231 " (with preallocated length of 80 characters or more) containing the\n"
17232 " file name.\n"
17233 "\n"
17234 ""},
17235 { "plgfont", _wrap_plgfont, METH_NOARGS, "\n"
17236 "Get family, style and weight of the current font\n"
17237 "\n"
17238 "DESCRIPTION:\n"
17239 "\n"
17240 " Gets information about current font. See the PLplot documentation for\n"
17241 " more information on font selection.\n"
17242 "\n"
17243 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17244 "\n"
17245 " This function is used in example 23.\n"
17246 "\n"
17247 "\n"
17248 "\n"
17249 "SYNOPSIS:\n"
17250 "\n"
17251 "plgfont(p_family, p_style, p_weight)\n"
17252 "\n"
17253 "ARGUMENTS:\n"
17254 "\n"
17255 " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17256 " font family. The available values are given by the PL_FCI_*\n"
17257 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17258 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17259 " p_family is NULL then the font family is not returned.\n"
17260 "\n"
17261 " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17262 " font style. The available values are given by the PL_FCI_*\n"
17263 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17264 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
17265 " style is not returned.\n"
17266 "\n"
17267 " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17268 " font weight. The available values are given by the PL_FCI_*\n"
17269 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17270 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17271 " returned.\n"
17272 "\n"
17273 ""},
17274 { "plglevel", _wrap_plglevel, METH_NOARGS, "\n"
17275 "Get the (current) run level\n"
17276 "\n"
17277 "DESCRIPTION:\n"
17278 "\n"
17279 " Get the (current) run level. Valid settings are: 0, uninitialized\n"
17280 " 1, initialized\n"
17281 " 2, viewport defined\n"
17282 " 3, world coordinates defined\n"
17283 "\n"
17284 "\n"
17285 " Redacted form: plglevel(p_level)\n"
17286 "\n"
17287 " This function is used in example 31.\n"
17288 "\n"
17289 "\n"
17290 "\n"
17291 "SYNOPSIS:\n"
17292 "\n"
17293 "plglevel(p_level)\n"
17294 "\n"
17295 "ARGUMENTS:\n"
17296 "\n"
17297 " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
17298 " level.\n"
17299 "\n"
17300 ""},
17301 { "plgpage", _wrap_plgpage, METH_NOARGS, "\n"
17302 "Get page parameters\n"
17303 "\n"
17304 "DESCRIPTION:\n"
17305 "\n"
17306 " Gets the current page configuration. The length and offset values are\n"
17307 " expressed in units that are specific to the current driver. For\n"
17308 " instance: screen drivers will usually interpret them as number of\n"
17309 " pixels, whereas printer drivers will usually use mm.\n"
17310 "\n"
17311 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17312 "\n"
17313 " This function is used in examples 14 and 31.\n"
17314 "\n"
17315 "\n"
17316 "\n"
17317 "SYNOPSIS:\n"
17318 "\n"
17319 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17320 "\n"
17321 "ARGUMENTS:\n"
17322 "\n"
17323 " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17324 " pixels/inch (DPI) in x.\n"
17325 "\n"
17326 " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17327 " pixels/inch (DPI) in y.\n"
17328 "\n"
17329 " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17330 " length.\n"
17331 "\n"
17332 " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17333 " length.\n"
17334 "\n"
17335 " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17336 " offset.\n"
17337 "\n"
17338 " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17339 " offset.\n"
17340 "\n"
17341 ""},
17342 { "plgra", _wrap_plgra, METH_NOARGS, "\n"
17343 "Switch to graphics screen\n"
17344 "\n"
17345 "DESCRIPTION:\n"
17346 "\n"
17347 " Sets an interactive device to graphics mode, used in conjunction with\n"
17348 " pltext to allow graphics and text to be interspersed. On a device\n"
17349 " which supports separate text and graphics windows, this command causes\n"
17350 " control to be switched to the graphics window. If already in graphics\n"
17351 " mode, this command is ignored. It is also ignored on devices which\n"
17352 " only support a single window or use a different method for shifting\n"
17353 " focus. See also pltext.\n"
17354 "\n"
17355 " Redacted form: plgra()\n"
17356 "\n"
17357 " This function is used in example 1.\n"
17358 "\n"
17359 "\n"
17360 "\n"
17361 "SYNOPSIS:\n"
17362 "\n"
17363 "plgra()\n"
17364 "\n"
17365 ""},
17366 { "plgriddata", _wrap_plgriddata, METH_VARARGS, "\n"
17367 "Grid data from irregularly sampled data\n"
17368 "\n"
17369 "DESCRIPTION:\n"
17370 "\n"
17371 " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
17372 " require data organized as a grid, i.e., with x sample point values\n"
17373 " independent of y coordinate and vice versa. This function takes\n"
17374 " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
17375 " vectors; reads the desired grid location from the input vectors\n"
17376 " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
17377 " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
17378 " interpolate the data to the grid is specified with the argument type\n"
17379 " which can have one parameter specified in argument data.\n"
17380 "\n"
17381 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17382 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17383 "\n"
17384 "\n"
17385 " This function is used in example 21.\n"
17386 "\n"
17387 "\n"
17388 "\n"
17389 "SYNOPSIS:\n"
17390 "\n"
17391 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17392 "\n"
17393 "ARGUMENTS:\n"
17394 "\n"
17395 " x (PLFLT_VECTOR, input) : The input x vector.\n"
17396 "\n"
17397 " y (PLFLT_VECTOR, input) : The input y vector.\n"
17398 "\n"
17399 " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
17400 " y[i], z[i] represents one data sample coordinate.\n"
17401 "\n"
17402 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17403 " vectors.\n"
17404 "\n"
17405 " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17406 " in the x direction. Usually xg has nptsx equally spaced values\n"
17407 " from the minimum to the maximum values of the x input vector.\n"
17408 "\n"
17409 " nptsx (PLINT, input) : The number of points in the xg vector.\n"
17410 "\n"
17411 " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17412 " in the y direction. Similar to the xg parameter.\n"
17413 "\n"
17414 " nptsy (PLINT, input) : The number of points in the yg vector.\n"
17415 "\n"
17416 " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
17417 " where data lies in the grid specified by xg and yg. Therefore the\n"
17418 " zg matrix must be dimensioned\n"
17419 " nptsx by\n"
17420 " nptsy.\n"
17421 "\n"
17422 " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17423 " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17424 " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17425 " GRID_NNI: Natural Neighbors Interpolation\n"
17426 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17427 " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17428 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17429 " Weighted\n"
17430 " For details of the algorithms read the source file plgridd.c.\n"
17431 "\n"
17432 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17433 " which can be specified through this argument. Currently, for\n"
17434 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17435 " use, the lower the value, the noisier (more local) the\n"
17436 " approximation is.\n"
17437 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17438 " range [1. .. 2.]. High values enable the usage of very thin\n"
17439 " triangles for interpolation, possibly resulting in error in\n"
17440 " the approximation.\n"
17441 " GRID_NNI, only weights greater than data will be accepted. If\n"
17442 " 0, all weights will be accepted.\n"
17443 "\n"
17444 ""},
17445 { "plgspa", _wrap_plgspa, METH_NOARGS, "\n"
17446 "Get current subpage parameters\n"
17447 "\n"
17448 "DESCRIPTION:\n"
17449 "\n"
17450 " Gets the size of the current subpage in millimeters measured from the\n"
17451 " bottom left hand corner of the output device page or screen. Can be\n"
17452 " used in conjunction with plsvpa for setting the size of a viewport in\n"
17453 " absolute coordinates (millimeters).\n"
17454 "\n"
17455 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17456 "\n"
17457 " This function is used in example 23.\n"
17458 "\n"
17459 "\n"
17460 "\n"
17461 "SYNOPSIS:\n"
17462 "\n"
17463 "plgspa(xmin, xmax, ymin, ymax)\n"
17464 "\n"
17465 "ARGUMENTS:\n"
17466 "\n"
17467 " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17468 " the left hand edge of the subpage in millimeters.\n"
17469 "\n"
17470 " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17471 " the right hand edge of the subpage in millimeters.\n"
17472 "\n"
17473 " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17474 " the bottom edge of the subpage in millimeters.\n"
17475 "\n"
17476 " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17477 " the top edge of the subpage in millimeters.\n"
17478 "\n"
17479 ""},
17480 { "plgstrm", _wrap_plgstrm, METH_NOARGS, "\n"
17481 "Get current stream number\n"
17482 "\n"
17483 "DESCRIPTION:\n"
17484 "\n"
17485 " Gets the number of the current output stream. See also plsstrm.\n"
17486 "\n"
17487 " Redacted form: plgstrm(p_strm)\n"
17488 "\n"
17489 " This function is used in example 1,20.\n"
17490 "\n"
17491 "\n"
17492 "\n"
17493 "SYNOPSIS:\n"
17494 "\n"
17495 "plgstrm(p_strm)\n"
17496 "\n"
17497 "ARGUMENTS:\n"
17498 "\n"
17499 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17500 " stream value.\n"
17501 "\n"
17502 ""},
17503 { "plgver", _wrap_plgver, METH_NOARGS, "\n"
17504 "Get the current library version number\n"
17505 "\n"
17506 "DESCRIPTION:\n"
17507 "\n"
17508 " Get the current library version number. Note: you must have allocated\n"
17509 " space for this (80 characters is safe).\n"
17510 "\n"
17511 " Redacted form: plgver(p_ver)\n"
17512 "\n"
17513 " This function is used in example 1.\n"
17514 "\n"
17515 "\n"
17516 "\n"
17517 "SYNOPSIS:\n"
17518 "\n"
17519 "plgver(p_ver)\n"
17520 "\n"
17521 "ARGUMENTS:\n"
17522 "\n"
17523 " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17524 " (with preallocated length of 80 characters or more) containing the\n"
17525 " PLplot version number.\n"
17526 "\n"
17527 ""},
17528 { "plgvpd", _wrap_plgvpd, METH_NOARGS, "\n"
17529 "Get viewport limits in normalized device coordinates\n"
17530 "\n"
17531 "DESCRIPTION:\n"
17532 "\n"
17533 " Get viewport limits in normalized device coordinates.\n"
17534 "\n"
17535 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17536 "\n"
17537 "\n"
17538 " This function is used in example 31.\n"
17539 "\n"
17540 "\n"
17541 "\n"
17542 "SYNOPSIS:\n"
17543 "\n"
17544 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17545 "\n"
17546 "ARGUMENTS:\n"
17547 "\n"
17548 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17549 " viewport limit of the normalized device coordinate in x.\n"
17550 "\n"
17551 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17552 " viewport limit of the normalized device coordinate in x.\n"
17553 "\n"
17554 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17555 " viewport limit of the normalized device coordinate in y.\n"
17556 "\n"
17557 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17558 " viewport limit of the normalized device coordinate in y.\n"
17559 "\n"
17560 ""},
17561 { "plgvpw", _wrap_plgvpw, METH_NOARGS, "\n"
17562 "Get viewport limits in world coordinates\n"
17563 "\n"
17564 "DESCRIPTION:\n"
17565 "\n"
17566 " Get viewport limits in world coordinates.\n"
17567 "\n"
17568 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17569 "\n"
17570 "\n"
17571 " This function is used in example 31.\n"
17572 "\n"
17573 "\n"
17574 "\n"
17575 "SYNOPSIS:\n"
17576 "\n"
17577 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17578 "\n"
17579 "ARGUMENTS:\n"
17580 "\n"
17581 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17582 " viewport limit of the world coordinate in x.\n"
17583 "\n"
17584 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17585 " viewport limit of the world coordinate in x.\n"
17586 "\n"
17587 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17588 " viewport limit of the world coordinate in y.\n"
17589 "\n"
17590 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17591 " viewport limit of the world coordinate in y.\n"
17592 "\n"
17593 ""},
17594 { "plgxax", _wrap_plgxax, METH_NOARGS, "\n"
17595 "Get x axis parameters\n"
17596 "\n"
17597 "DESCRIPTION:\n"
17598 "\n"
17599 " Returns current values of the p_digmax and p_digits flags for the x\n"
17600 " axis. p_digits is updated after the plot is drawn, so this routine\n"
17601 " should only be called after the call to plbox (or plbox3) is complete.\n"
17602 " See the PLplot documentation for more information.\n"
17603 "\n"
17604 " Redacted form: plgxax(p_digmax, p_digits)\n"
17605 "\n"
17606 " This function is used in example 31.\n"
17607 "\n"
17608 "\n"
17609 "\n"
17610 "SYNOPSIS:\n"
17611 "\n"
17612 "plgxax(p_digmax, p_digits)\n"
17613 "\n"
17614 "ARGUMENTS:\n"
17615 "\n"
17616 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17617 " number of digits for the x axis. If nonzero, the printed label\n"
17618 " has been switched to a floating-point representation when the\n"
17619 " number of digits exceeds this value.\n"
17620 "\n"
17621 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17622 " number of digits for the numeric labels (x axis) from the last\n"
17623 " plot.\n"
17624 "\n"
17625 ""},
17626 { "plgyax", _wrap_plgyax, METH_NOARGS, "\n"
17627 "Get y axis parameters\n"
17628 "\n"
17629 "DESCRIPTION:\n"
17630 "\n"
17631 " Identical to plgxax, except that arguments are flags for y axis. See\n"
17632 " the description of plgxax for more detail.\n"
17633 "\n"
17634 " Redacted form: plgyax(p_digmax, p_digits)\n"
17635 "\n"
17636 " This function is used in example 31.\n"
17637 "\n"
17638 "\n"
17639 "\n"
17640 "SYNOPSIS:\n"
17641 "\n"
17642 "plgyax(p_digmax, p_digits)\n"
17643 "\n"
17644 "ARGUMENTS:\n"
17645 "\n"
17646 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17647 " number of digits for the y axis. If nonzero, the printed label\n"
17648 " has been switched to a floating-point representation when the\n"
17649 " number of digits exceeds this value.\n"
17650 "\n"
17651 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17652 " number of digits for the numeric labels (y axis) from the last\n"
17653 " plot.\n"
17654 "\n"
17655 ""},
17656 { "plgzax", _wrap_plgzax, METH_NOARGS, "\n"
17657 "Get z axis parameters\n"
17658 "\n"
17659 "DESCRIPTION:\n"
17660 "\n"
17661 " Identical to plgxax, except that arguments are flags for z axis. See\n"
17662 " the description of plgxax for more detail.\n"
17663 "\n"
17664 " Redacted form: plgzax(p_digmax, p_digits)\n"
17665 "\n"
17666 " This function is used in example 31.\n"
17667 "\n"
17668 "\n"
17669 "\n"
17670 "SYNOPSIS:\n"
17671 "\n"
17672 "plgzax(p_digmax, p_digits)\n"
17673 "\n"
17674 "ARGUMENTS:\n"
17675 "\n"
17676 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17677 " number of digits for the z axis. If nonzero, the printed label\n"
17678 " has been switched to a floating-point representation when the\n"
17679 " number of digits exceeds this value.\n"
17680 "\n"
17681 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17682 " number of digits for the numeric labels (z axis) from the last\n"
17683 " plot.\n"
17684 "\n"
17685 ""},
17686 { "plhist", _wrap_plhist, METH_VARARGS, "\n"
17687 "Plot a histogram from unbinned data\n"
17688 "\n"
17689 "DESCRIPTION:\n"
17690 "\n"
17691 " Plots a histogram from n data points stored in the data vector. This\n"
17692 " routine bins the data into nbin bins equally spaced between datmin and\n"
17693 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17694 " opt allows, among other things, the histogram either to be plotted in\n"
17695 " an existing window or causes plhist to call plenv with suitable limits\n"
17696 " before plotting the histogram.\n"
17697 "\n"
17698 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17699 "\n"
17700 " This function is used in example 5.\n"
17701 "\n"
17702 "\n"
17703 "\n"
17704 "SYNOPSIS:\n"
17705 "\n"
17706 "plhist(n, data, datmin, datmax, nbin, opt)\n"
17707 "\n"
17708 "ARGUMENTS:\n"
17709 "\n"
17710 " n (PLINT, input) : Number of data points.\n"
17711 "\n"
17712 " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17713 " n data points.\n"
17714 "\n"
17715 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17716 "\n"
17717 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17718 "\n"
17719 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17720 " divide the interval xmin to xmax.\n"
17721 "\n"
17722 " opt (PLINT, input) : Is a combination of several flags:\n"
17723 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17724 " the histogram data, the outer bins are expanded to fill up the\n"
17725 " entire x-axis, data outside the given extremes are assigned to the\n"
17726 " outer bins and bins of zero height are simply drawn.\n"
17727 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17728 " to fit the histogram data, without this flag, plenv is called\n"
17729 " to set the world coordinates.\n"
17730 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17731 " extremes are not taken into account. This option should\n"
17732 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17733 " properly present the data.\n"
17734 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17735 " size as the ones inside.\n"
17736 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17737 " (there is a gap for such bins).\n"
17738 "\n"
17739 ""},
17740 { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, "\n"
17741 "Convert HLS color to RGB\n"
17742 "\n"
17743 "DESCRIPTION:\n"
17744 "\n"
17745 " Convert HLS color coordinates to RGB.\n"
17746 "\n"
17747 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17748 "\n"
17749 "\n"
17750 " This function is used in example 2.\n"
17751 "\n"
17752 "\n"
17753 "\n"
17754 "SYNOPSIS:\n"
17755 "\n"
17756 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17757 "\n"
17758 "ARGUMENTS:\n"
17759 "\n"
17760 " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17761 " cylinder.\n"
17762 "\n"
17763 " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17764 " the axis of the color cylinder.\n"
17765 "\n"
17766 " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17767 " the radius of the color cylinder.\n"
17768 "\n"
17769 " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17770 " (0.0-1.0) of the color.\n"
17771 "\n"
17772 " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17773 " intensity (0.0-1.0) of the color.\n"
17774 "\n"
17775 " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17776 " intensity (0.0-1.0) of the color.\n"
17777 "\n"
17778 ""},
17779 { "plinit", _wrap_plinit, METH_NOARGS, "\n"
17780 "Initialize PLplot\n"
17781 "\n"
17782 "DESCRIPTION:\n"
17783 "\n"
17784 " Initializing the plotting package. The program prompts for the device\n"
17785 " keyword or number of the desired output device. Hitting a RETURN in\n"
17786 " response to the prompt is the same as selecting the first device.\n"
17787 " plinit will issue no prompt if either the device was specified\n"
17788 " previously (via command line flag, the plsetopt function, or the\n"
17789 " plsdev function), or if only one device is enabled when PLplot is\n"
17790 " installed. If subpages have been specified, the output device is\n"
17791 " divided into nx by ny subpages, each of which may be used\n"
17792 " independently. If plinit is called again during a program, the\n"
17793 " previously opened file will be closed. The subroutine pladv is used\n"
17794 " to advance from one subpage to the next.\n"
17795 "\n"
17796 " Redacted form: plinit()\n"
17797 "\n"
17798 " This function is used in all of the examples.\n"
17799 "\n"
17800 "\n"
17801 "\n"
17802 "SYNOPSIS:\n"
17803 "\n"
17804 "plinit()\n"
17805 "\n"
17806 ""},
17807 { "pljoin", _wrap_pljoin, METH_VARARGS, "\n"
17808 "Draw a line between two points\n"
17809 "\n"
17810 "DESCRIPTION:\n"
17811 "\n"
17812 " Joins the point (\n"
17813 " x1,\n"
17814 " y1) to (\n"
17815 " x2,\n"
17816 " y2).\n"
17817 "\n"
17818 " Redacted form: pljoin(x1,y1,x2,y2)\n"
17819 "\n"
17820 " This function is used in examples 3 and 14.\n"
17821 "\n"
17822 "\n"
17823 "\n"
17824 "SYNOPSIS:\n"
17825 "\n"
17826 "pljoin(x1, y1, x2, y2)\n"
17827 "\n"
17828 "ARGUMENTS:\n"
17829 "\n"
17830 " x1 (PLFLT, input) : x coordinate of first point.\n"
17831 "\n"
17832 " y1 (PLFLT, input) : y coordinate of first point.\n"
17833 "\n"
17834 " x2 (PLFLT, input) : x coordinate of second point.\n"
17835 "\n"
17836 " y2 (PLFLT, input) : y coordinate of second point.\n"
17837 "\n"
17838 ""},
17839 { "pllab", _wrap_pllab, METH_VARARGS, "\n"
17840 "Simple routine to write labels\n"
17841 "\n"
17842 "DESCRIPTION:\n"
17843 "\n"
17844 " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17845 "\n"
17846 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17847 "\n"
17848 " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17849 "\n"
17850 "\n"
17851 "\n"
17852 "SYNOPSIS:\n"
17853 "\n"
17854 "pllab(xlabel, ylabel, tlabel)\n"
17855 "\n"
17856 "ARGUMENTS:\n"
17857 "\n"
17858 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17859 " the label for the x axis.\n"
17860 "\n"
17861 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17862 " the label for the y axis.\n"
17863 "\n"
17864 " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17865 " the title of the plot.\n"
17866 "\n"
17867 ""},
17868 { "pllegend", _wrap_pllegend, METH_VARARGS, "\n"
17869 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17870 "\n"
17871 "DESCRIPTION:\n"
17872 "\n"
17873 " Routine for creating a discrete plot legend with a plotted filled box,\n"
17874 " line, and/or line of symbols for each annotated legend entry. (See\n"
17875 " plcolorbar for similar functionality for creating continuous color\n"
17876 " bars.) The arguments of pllegend provide control over the location\n"
17877 " and size of the legend as well as the location and characteristics of\n"
17878 " the elements (most of which are optional) within that legend. The\n"
17879 " resulting legend is clipped at the boundaries of the current subpage.\n"
17880 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17881 " defined in the documentation of the position parameter.)\n"
17882 "\n"
17883 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17884 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17885 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17886 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17887 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17888 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17889 "\n"
17890 " This function is used in examples 4, 26, and 33.\n"
17891 "\n"
17892 "\n"
17893 "\n"
17894 "SYNOPSIS:\n"
17895 "\n"
17896 "pllegend(p_legend_width, p_legend_height, opt, position, x, y, plot_width, bg_color, bb_color, bb_style, nrow, ncolumn, nlegend, opt_array, text_offset, text_scale, text_spacing, test_justification, text_colors, text, box_colors, box_patterns, box_scales, box_line_widths, line_colors, line_styles, line_widths, symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17897 "\n"
17898 "ARGUMENTS:\n"
17899 "\n"
17900 " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17901 " legend width in adopted coordinates. This quantity is calculated\n"
17902 " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17903 " the routine depending on nlegend and nrow), and the length\n"
17904 " (calculated internally) of the longest text string.\n"
17905 "\n"
17906 " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17907 " legend height in adopted coordinates. This quantity is calculated\n"
17908 " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17909 " the routine depending on nlegend and nrow).\n"
17910 "\n"
17911 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17912 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17913 " on the left of the legend and the plotted area on the right.\n"
17914 " Otherwise, put the text area on the right of the legend and the\n"
17915 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17916 " plot a (semitransparent) background for the legend. If the\n"
17917 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17918 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17919 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17920 " plot the resulting array of legend entries in row-major order.\n"
17921 " Otherwise, plot the legend entries in column-major order.\n"
17922 "\n"
17923 " position (PLINT, input) : position contains bits which control the\n"
17924 " overall position of the legend and the definition of the adopted\n"
17925 " coordinates used for positions just like what is done for the\n"
17926 " position argument for plcolorbar. However, note that the defaults\n"
17927 " for the position bits (see below) are different than the\n"
17928 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17929 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17930 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17931 " the 16 possible standard positions (the 4 corners and centers of\n"
17932 " the 4 sides for both the inside and outside cases) of the legend\n"
17933 " relative to the adopted coordinate system. The corner positions\n"
17934 " are specified by the appropriate combination of two of the\n"
17935 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17936 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17937 " value of one of those bits. The adopted coordinates are\n"
17938 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17939 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17940 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17941 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17942 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17943 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17944 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17945 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17946 "\n"
17947 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17948 " coordinates from the specified standard position of the legend.\n"
17949 " For positive x, the direction of motion away from the standard\n"
17950 " position is inward/outward from the standard corner positions or\n"
17951 " standard left or right positions if the\n"
17952 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17953 " For the standard top or bottom positions, the direction of motion\n"
17954 " is toward positive X.\n"
17955 "\n"
17956 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17957 " coordinates from the specified standard position of the legend.\n"
17958 " For positive y, the direction of motion away from the standard\n"
17959 " position is inward/outward from the standard corner positions or\n"
17960 " standard top or bottom positions if the\n"
17961 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17962 " the standard left or right positions, the direction of motion is\n"
17963 " toward positive Y.\n"
17964 "\n"
17965 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17966 " of the plot area (where the colored boxes, lines, and/or lines of\n"
17967 " symbols are drawn) of the legend.\n"
17968 "\n"
17969 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17970 " legend (PL_LEGEND_BACKGROUND).\n"
17971 "\n"
17972 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17973 " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17974 "\n"
17975 " bb_style (PLINT, input) : The pllsty style number for the\n"
17976 " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
17977 "\n"
17978 " nrow (PLINT, input) : The number of rows in the matrix used to\n"
17979 " render the\n"
17980 " nlegend legend entries. For internal transformations of\n"
17981 " nrow, see further remarks under\n"
17982 " nlegend.\n"
17983 "\n"
17984 " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
17985 " to render the\n"
17986 " nlegend legend entries. For internal transformations of\n"
17987 " ncolumn, see further remarks under\n"
17988 " nlegend.\n"
17989 "\n"
17990 " nlegend (PLINT, input) : Number of legend entries. The above\n"
17991 " nrow and\n"
17992 " ncolumn values are transformed internally to be consistent with\n"
17993 " nlegend. If either\n"
17994 " nrow or\n"
17995 " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
17996 " of\n"
17997 " nrow and\n"
17998 " ncolumn is less than\n"
17999 " nlegend, the smaller of the two (or\n"
18000 " nrow, if\n"
18001 " nrow ==\n"
18002 " ncolumn) is increased so the product is >=\n"
18003 " nlegend. Thus, for example, the common\n"
18004 " nrow = 0,\n"
18005 " ncolumn = 0 case is transformed internally to\n"
18006 " nrow =\n"
18007 " nlegend,\n"
18008 " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
18009 " column.\n"
18010 "\n"
18011 " opt_array (PLINT_VECTOR, input) : A vector of\n"
18012 " nlegend values of options to control each individual plotted area\n"
18013 " corresponding to a legend entry. If the\n"
18014 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
18015 " area. If the\n"
18016 " PL_LEGEND_COLOR_BOX,\n"
18017 " PL_LEGEND_LINE, and/or\n"
18018 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
18019 " entry is plotted with a colored box; a line; and/or a line of\n"
18020 " symbols.\n"
18021 "\n"
18022 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
18023 " area in units of character width.\n"
18024 "\n"
18025 " text_scale (PLFLT, input) : Character height scale for text\n"
18026 " annotations.\n"
18027 "\n"
18028 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
18029 " character height from one legend entry to the next.\n"
18030 "\n"
18031 " text_justification (PLFLT, input) : Justification parameter used\n"
18032 " for text justification. The most common values of\n"
18033 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
18034 " is left justified, centred, or right justified within the text\n"
18035 " area, but other values are allowed as well.\n"
18036 "\n"
18037 " text_colors (PLINT_VECTOR, input) : A vector containing\n"
18038 " nlegend cmap0 text colors.\n"
18039 "\n"
18040 " text (PLCHAR_MATRIX, input) : A vector of\n"
18041 " nlegend UTF-8 character strings containing the legend annotations.\n"
18042 "\n"
18043 " box_colors (PLINT_VECTOR, input) : A vector containing\n"
18044 " nlegend cmap0 colors for the discrete colored boxes (\n"
18045 " PL_LEGEND_COLOR_BOX).\n"
18046 "\n"
18047 " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
18048 " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
18049 " PL_LEGEND_COLOR_BOX).\n"
18050 "\n"
18051 " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
18052 " nlegend scales (units of fraction of character height) for the height\n"
18053 " of the discrete colored boxes (\n"
18054 " PL_LEGEND_COLOR_BOX).\n"
18055 "\n"
18056 " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18057 " nlegend line widths for the patterns specified by box_patterns (\n"
18058 " PL_LEGEND_COLOR_BOX).\n"
18059 "\n"
18060 " line_colors (PLINT_VECTOR, input) : A vector containing\n"
18061 " nlegend cmap0 line colors (\n"
18062 " PL_LEGEND_LINE).\n"
18063 "\n"
18064 " line_styles (PLINT_VECTOR, input) : A vector containing\n"
18065 " nlegend line styles (plsty indices) (\n"
18066 " PL_LEGEND_LINE).\n"
18067 "\n"
18068 " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18069 " nlegend line widths (\n"
18070 " PL_LEGEND_LINE).\n"
18071 "\n"
18072 " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
18073 " nlegend cmap0 symbol colors (\n"
18074 " PL_LEGEND_SYMBOL).\n"
18075 "\n"
18076 " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
18077 " nlegend scale values for the symbol height (\n"
18078 " PL_LEGEND_SYMBOL).\n"
18079 "\n"
18080 " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
18081 " nlegend numbers of symbols to be drawn across the width of the plotted\n"
18082 " area (\n"
18083 " PL_LEGEND_SYMBOL).\n"
18084 "\n"
18085 " symbols (PLCHAR_MATRIX, input) : A vector of\n"
18086 " nlegend UTF-8 character strings containing the legend symbols. (\n"
18087 " PL_LEGEND_SYMBOL).\n"
18088 "\n"
18089 ""},
18090 { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, "\n"
18091 "Plot color bar for image, shade or gradient plots\n"
18092 "\n"
18093 "DESCRIPTION:\n"
18094 "\n"
18095 " Routine for creating a continuous color bar for image, shade, or\n"
18096 " gradient plots. (See pllegend for similar functionality for creating\n"
18097 " legends with discrete elements). The arguments of plcolorbar provide\n"
18098 " control over the location and size of the color bar as well as the\n"
18099 " location and characteristics of the elements (most of which are\n"
18100 " optional) within that color bar. The resulting color bar is clipped\n"
18101 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
18102 " system used for some of the parameters is defined in the documentation\n"
18103 " of the position parameter.)\n"
18104 "\n"
18105 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
18106 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
18107 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
18108 " labels, axis_opts, ticks, sub_ticks, values)\n"
18109 "\n"
18110 " This function is used in examples 16 and 33.\n"
18111 "\n"
18112 "\n"
18113 "\n"
18114 "SYNOPSIS:\n"
18115 "\n"
18116 "plcolorbar(p_colorbar_width, p_colorbar_height, opt, position, x, y, x_length, y_length, bg_color, bb_color, bb_style, low_cap_color, high_cap_color, cont_color, cont_width, n_labels, label_opts, labels, naxes, axis_opts, ticks, sub_ticks, n_values, values)\n"
18117 "\n"
18118 "ARGUMENTS:\n"
18119 "\n"
18120 " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18121 " labelled and decorated color bar width in adopted coordinates.\n"
18122 "\n"
18123 " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18124 " labelled and decorated color bar height in adopted coordinates.\n"
18125 "\n"
18126 " opt (PLINT, input) : opt contains bits controlling the overall\n"
18127 " color bar. The orientation (direction of the maximum value) of\n"
18128 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
18129 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
18130 " specified, the default orientation is toward the top if the\n"
18131 " colorbar is placed on the left or right of the viewport or toward\n"
18132 " the right if the colorbar is placed on the top or bottom of the\n"
18133 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
18134 " (semitransparent) background for the color bar. If the\n"
18135 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
18136 " color bar. The type of color bar must be specified with one of\n"
18137 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
18138 " more than one of those bits is set only the first one in the above\n"
18139 " list is honored. The position of the (optional) label/title can be\n"
18140 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
18141 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
18142 " will be drawn. If more than one of this list of bits is specified,\n"
18143 " only the first one on the list is honored. End-caps for the color\n"
18144 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
18145 " If a particular color bar cap option is not specified then no cap\n"
18146 " will be drawn for that end. As a special case for\n"
18147 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
18148 " specified. If this option is provided then any tick marks and tick\n"
18149 " labels will be placed at the breaks between shaded segments. TODO:\n"
18150 " This should be expanded to support custom placement of tick marks\n"
18151 " and tick labels at custom value locations for any color bar type.\n"
18152 "\n"
18153 " position (PLINT, input) : position contains bits which control the\n"
18154 " overall position of the color bar and the definition of the\n"
18155 " adopted coordinates used for positions just like what is done for\n"
18156 " the position argument for pllegend. However, note that the\n"
18157 " defaults for the position bits (see below) are different than the\n"
18158 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
18159 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
18160 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
18161 " the 16 possible standard positions (the 4 corners and centers of\n"
18162 " the 4 sides for both the inside and outside cases) of the color\n"
18163 " bar relative to the adopted coordinate system. The corner\n"
18164 " positions are specified by the appropriate combination of two of\n"
18165 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
18166 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
18167 " value of one of those bits. The adopted coordinates are\n"
18168 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
18169 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
18170 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
18171 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
18172 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
18173 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
18174 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
18175 " PL_POSITION_VIEWPORT.\n"
18176 "\n"
18177 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
18178 " coordinates from the specified standard position of the color bar.\n"
18179 " For positive x, the direction of motion away from the standard\n"
18180 " position is inward/outward from the standard corner positions or\n"
18181 " standard left or right positions if the\n"
18182 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18183 " For the standard top or bottom positions, the direction of motion\n"
18184 " is toward positive X.\n"
18185 "\n"
18186 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
18187 " coordinates from the specified standard position of the color bar.\n"
18188 " For positive y, the direction of motion away from the standard\n"
18189 " position is inward/outward from the standard corner positions or\n"
18190 " standard top or bottom positions if the\n"
18191 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18192 " For the standard left or right positions, the direction of motion\n"
18193 " is toward positive Y.\n"
18194 "\n"
18195 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
18196 " the X direction in adopted coordinates.\n"
18197 "\n"
18198 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
18199 " the Y direction in adopted coordinates.\n"
18200 "\n"
18201 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18202 " color bar (PL_COLORBAR_BACKGROUND).\n"
18203 "\n"
18204 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18205 " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
18206 "\n"
18207 " bb_style (PLINT, input) : The pllsty style number for the\n"
18208 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
18209 "\n"
18210 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
18211 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
18212 "\n"
18213 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
18214 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
18215 "\n"
18216 " cont_color (PLINT, input) : The cmap0 contour color for\n"
18217 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
18218 " it will be interpreted according to the design of plshades.\n"
18219 "\n"
18220 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18221 " plots. This is passed directly to plshades, so it will be\n"
18222 " interpreted according to the design of plshades.\n"
18223 "\n"
18224 " n_labels (PLINT, input) : Number of labels to place around the\n"
18225 " color bar.\n"
18226 "\n"
18227 " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
18228 " n_labels labels.\n"
18229 "\n"
18230 " labels (PLCHAR_MATRIX, input) : A vector of\n"
18231 " n_labels UTF-8 character strings containing the labels for the color\n"
18232 " bar. Ignored if no label position is specified with one of the\n"
18233 " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18234 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18235 " corresponding label_opts field.\n"
18236 "\n"
18237 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18238 " value must be greater than 0. It is typically 1 (numerical axis\n"
18239 " labels are provided for one of the long edges of the color bar),\n"
18240 " but it can be larger if multiple numerical axis labels for the\n"
18241 " long edges of the color bar are desired.\n"
18242 "\n"
18243 " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
18244 " n_axes ascii character strings containing options (interpreted as for\n"
18245 " plbox) for the color bar's axis definitions.\n"
18246 "\n"
18247 " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
18248 " spacing of the major tick marks (interpreted as for plbox) for the\n"
18249 " color bar's axis definitions.\n"
18250 "\n"
18251 " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
18252 " number of subticks (interpreted as for plbox) for the color bar's\n"
18253 " axis definitions.\n"
18254 "\n"
18255 " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
18256 " elements in each of the n_axes rows of the values matrix.\n"
18257 "\n"
18258 " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
18259 " values for the data range represented by the color bar. For a row\n"
18260 " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
18261 " elements in the row is specified by n_values[i_axis]. For\n"
18262 " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
18263 " is 2, and the corresponding row elements of the values matrix are\n"
18264 " the minimum and maximum value represented by the colorbar. For\n"
18265 " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
18266 " of the values matrix is interpreted the same as the nlevel and\n"
18267 " clevel arguments of plshades.\n"
18268 "\n"
18269 ""},
18270 { "pllightsource", _wrap_pllightsource, METH_VARARGS, "\n"
18271 "Sets the 3D position of the light source\n"
18272 "\n"
18273 "DESCRIPTION:\n"
18274 "\n"
18275 " Sets the 3D position of the light source for use with plsurf3d and\n"
18276 " plsurf3dl\n"
18277 "\n"
18278 " Redacted form: pllightsource(x, y, z)\n"
18279 "\n"
18280 " This function is used in example 8.\n"
18281 "\n"
18282 "\n"
18283 "\n"
18284 "SYNOPSIS:\n"
18285 "\n"
18286 "pllightsource(x, y, z)\n"
18287 "\n"
18288 "ARGUMENTS:\n"
18289 "\n"
18290 " x (PLFLT, input) : X-coordinate of the light source.\n"
18291 "\n"
18292 " y (PLFLT, input) : Y-coordinate of the light source.\n"
18293 "\n"
18294 " z (PLFLT, input) : Z-coordinate of the light source.\n"
18295 "\n"
18296 ""},
18297 { "plline", _wrap_plline, METH_VARARGS, "\n"
18298 "Draw a line\n"
18299 "\n"
18300 "DESCRIPTION:\n"
18301 "\n"
18302 " Draws line defined by n points in x and y.\n"
18303 "\n"
18304 " Redacted form: plline(x, y)\n"
18305 "\n"
18306 " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
18307 " 25-27, and 29.\n"
18308 "\n"
18309 "\n"
18310 "\n"
18311 "SYNOPSIS:\n"
18312 "\n"
18313 "plline(n, x, y)\n"
18314 "\n"
18315 "ARGUMENTS:\n"
18316 "\n"
18317 " n (PLINT, input) : Number of points defining line.\n"
18318 "\n"
18319 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18320 " points.\n"
18321 "\n"
18322 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18323 " points.\n"
18324 "\n"
18325 ""},
18326 { "plline3", _wrap_plline3, METH_VARARGS, "\n"
18327 "Draw a line in 3 space\n"
18328 "\n"
18329 "DESCRIPTION:\n"
18330 "\n"
18331 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18332 " first set up the viewport, the 2d viewing window (in world\n"
18333 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18334 " more info.\n"
18335 "\n"
18336 " Redacted form: plline3(x, y, z)\n"
18337 "\n"
18338 " This function is used in example 18.\n"
18339 "\n"
18340 "\n"
18341 "\n"
18342 "SYNOPSIS:\n"
18343 "\n"
18344 "plline3(n, x, y, z)\n"
18345 "\n"
18346 "ARGUMENTS:\n"
18347 "\n"
18348 " n (PLINT, input) : Number of points defining line.\n"
18349 "\n"
18350 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18351 " points.\n"
18352 "\n"
18353 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18354 " points.\n"
18355 "\n"
18356 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18357 " points.\n"
18358 "\n"
18359 ""},
18360 { "pllsty", _wrap_pllsty, METH_O, "\n"
18361 "Select line style\n"
18362 "\n"
18363 "DESCRIPTION:\n"
18364 "\n"
18365 " This sets the line style according to one of eight predefined patterns\n"
18366 " (also see plstyl).\n"
18367 "\n"
18368 " Redacted form: pllsty(lin)\n"
18369 "\n"
18370 " This function is used in examples 9, 12, 22, and 25.\n"
18371 "\n"
18372 "\n"
18373 "\n"
18374 "SYNOPSIS:\n"
18375 "\n"
18376 "pllsty(lin)\n"
18377 "\n"
18378 "ARGUMENTS:\n"
18379 "\n"
18380 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18381 " a continuous line, line style 2 is a line with short dashes and\n"
18382 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18383 " 4 has long dashes and short gaps and so on.\n"
18384 "\n"
18385 ""},
18386 { "plmesh", _wrap_plmesh, METH_VARARGS, "\n"
18387 "Plot surface mesh\n"
18388 "\n"
18389 "DESCRIPTION:\n"
18390 "\n"
18391 " Plots a surface mesh within the environment set up by plw3d. The\n"
18392 " surface is defined by the matrix z[\n"
18393 " nx][\n"
18394 " ny] , the point z[i][j] being the value of the function at (\n"
18395 " x[i],\n"
18396 " y[j]). Note that the points in vectors x and y do not need to be\n"
18397 " equally spaced, but must be stored in ascending order. The parameter\n"
18398 " opt controls the way in which the surface is displayed. For further\n"
18399 " details see the PLplot documentation.\n"
18400 "\n"
18401 " Redacted form: plmesh(x, y, z, opt)\n"
18402 "\n"
18403 " This function is used in example 11.\n"
18404 "\n"
18405 "\n"
18406 "\n"
18407 "SYNOPSIS:\n"
18408 "\n"
18409 "plmesh(x, y, z, nx, ny, opt)\n"
18410 "\n"
18411 "ARGUMENTS:\n"
18412 "\n"
18413 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18414 " which the function is evaluated.\n"
18415 "\n"
18416 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18417 " which the function is evaluated.\n"
18418 "\n"
18419 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18420 " plot. Should have dimensions of\n"
18421 " nx by\n"
18422 " ny.\n"
18423 "\n"
18424 " nx (PLINT, input) : Number of x values at which function has been\n"
18425 " evaluated.\n"
18426 "\n"
18427 " ny (PLINT, input) : Number of y values at which function has been\n"
18428 " evaluated.\n"
18429 "\n"
18430 " opt (PLINT, input) : Determines the way in which the surface is\n"
18431 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18432 " function of x for each value of y[j] .\n"
18433 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18434 " for each value of x[i] .\n"
18435 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18436 " at which function is defined.\n"
18437 "\n"
18438 ""},
18439 { "plmeshc", _wrap_plmeshc, METH_VARARGS, "\n"
18440 "Magnitude colored plot surface mesh with contour\n"
18441 "\n"
18442 "DESCRIPTION:\n"
18443 "\n"
18444 " A more powerful form of plmesh: the surface mesh can be colored\n"
18445 " accordingly to the current z value being plotted, a contour plot can\n"
18446 " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18447 " plotted function border and the base XY plane.\n"
18448 "\n"
18449 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18450 "\n"
18451 " This function is used in example 11.\n"
18452 "\n"
18453 "\n"
18454 "\n"
18455 "SYNOPSIS:\n"
18456 "\n"
18457 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18458 "\n"
18459 "ARGUMENTS:\n"
18460 "\n"
18461 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18462 " which the function is evaluated.\n"
18463 "\n"
18464 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18465 " which the function is evaluated.\n"
18466 "\n"
18467 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18468 " plot. Should have dimensions of\n"
18469 " nx by\n"
18470 " ny.\n"
18471 "\n"
18472 " nx (PLINT, input) : Number of x values at which function is\n"
18473 " evaluated.\n"
18474 "\n"
18475 " ny (PLINT, input) : Number of y values at which function is\n"
18476 " evaluated.\n"
18477 "\n"
18478 " opt (PLINT, input) : Determines the way in which the surface is\n"
18479 " represented. To specify more than one option just add the options,\n"
18480 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18481 " showing z as a function of x for each value of y[j] .\n"
18482 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18483 " for each value of x[i] .\n"
18484 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18485 " at which function is defined.\n"
18486 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18487 " the z value being plotted. The color is used from the current\n"
18488 " cmap1.\n"
18489 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18490 " using parameters\n"
18491 " nlevel and\n"
18492 " clevel.\n"
18493 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18494 " the borders of the plotted function.\n"
18495 "\n"
18496 "\n"
18497 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18498 " levels.\n"
18499 "\n"
18500 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18501 "\n"
18502 ""},
18503 { "plmkstrm", _wrap_plmkstrm, METH_NOARGS, "\n"
18504 "Creates a new stream and makes it the default\n"
18505 "\n"
18506 "DESCRIPTION:\n"
18507 "\n"
18508 " Creates a new stream and makes it the default. Differs from using\n"
18509 " plsstrm, in that a free stream number is found, and returned.\n"
18510 " Unfortunately, I have to start at stream 1 and work upward, since\n"
18511 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18512 " that no initial, library-opening call is required. So stream 0 must\n"
18513 " be preallocated, and there is no simple way of determining whether it\n"
18514 " is already in use or not.\n"
18515 "\n"
18516 " Redacted form: plmkstrm(p_strm)\n"
18517 "\n"
18518 " This function is used in examples 1 and 20.\n"
18519 "\n"
18520 "\n"
18521 "\n"
18522 "SYNOPSIS:\n"
18523 "\n"
18524 "plmkstrm(p_strm)\n"
18525 "\n"
18526 "ARGUMENTS:\n"
18527 "\n"
18528 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18529 " number of the created stream.\n"
18530 "\n"
18531 ""},
18532 { "plmtex", _wrap_plmtex, METH_VARARGS, "\n"
18533 "Write text relative to viewport boundaries\n"
18534 "\n"
18535 "DESCRIPTION:\n"
18536 "\n"
18537 " Writes text at a specified position relative to the viewport\n"
18538 " boundaries. Text may be written inside or outside the viewport, but\n"
18539 " is clipped at the subpage boundaries. The reference point of a string\n"
18540 " lies along a line passing through the string at half the height of a\n"
18541 " capital letter. The position of the reference point along this line\n"
18542 " is determined by just, and the position of the reference point\n"
18543 " relative to the viewport is set by disp and pos.\n"
18544 "\n"
18545 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18546 "\n"
18547 "\n"
18548 " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18549 " 26.\n"
18550 "\n"
18551 "\n"
18552 "\n"
18553 "SYNOPSIS:\n"
18554 "\n"
18555 "plmtex(side, disp, pos, just, text)\n"
18556 "\n"
18557 "ARGUMENTS:\n"
18558 "\n"
18559 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18560 " the side of the viewport along which the text is to be written.\n"
18561 " The string must be one of: b: Bottom of viewport, text written\n"
18562 " parallel to edge.\n"
18563 " bv: Bottom of viewport, text written at right angles to edge.\n"
18564 " l: Left of viewport, text written parallel to edge.\n"
18565 " lv: Left of viewport, text written at right angles to edge.\n"
18566 " r: Right of viewport, text written parallel to edge.\n"
18567 " rv: Right of viewport, text written at right angles to edge.\n"
18568 " t: Top of viewport, text written parallel to edge.\n"
18569 " tv: Top of viewport, text written at right angles to edge.\n"
18570 "\n"
18571 "\n"
18572 " disp (PLFLT, input) : Position of the reference point of string,\n"
18573 " measured outwards from the specified viewport edge in units of the\n"
18574 " current character height. Use negative disp to write within the\n"
18575 " viewport.\n"
18576 "\n"
18577 " pos (PLFLT, input) : Position of the reference point of string\n"
18578 " along the specified edge, expressed as a fraction of the length of\n"
18579 " the edge.\n"
18580 "\n"
18581 " just (PLFLT, input) : Specifies the position of the string relative\n"
18582 " to its reference point. If just=0. , the reference point is at\n"
18583 " the left and if just=1. , it is at the right of the string. Other\n"
18584 " values of just give intermediate justifications.\n"
18585 "\n"
18586 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18587 " written out.\n"
18588 "\n"
18589 ""},
18590 { "plmtex3", _wrap_plmtex3, METH_VARARGS, "\n"
18591 "Write text relative to viewport boundaries in 3D plots\n"
18592 "\n"
18593 "DESCRIPTION:\n"
18594 "\n"
18595 " Writes text at a specified position relative to the viewport\n"
18596 " boundaries. Text may be written inside or outside the viewport, but\n"
18597 " is clipped at the subpage boundaries. The reference point of a string\n"
18598 " lies along a line passing through the string at half the height of a\n"
18599 " capital letter. The position of the reference point along this line\n"
18600 " is determined by just, and the position of the reference point\n"
18601 " relative to the viewport is set by disp and pos.\n"
18602 "\n"
18603 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18604 "\n"
18605 " This function is used in example 28.\n"
18606 "\n"
18607 "\n"
18608 "\n"
18609 "SYNOPSIS:\n"
18610 "\n"
18611 "plmtex3(side, disp, pos, just, text)\n"
18612 "\n"
18613 "ARGUMENTS:\n"
18614 "\n"
18615 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18616 " the side of the viewport along which the text is to be written.\n"
18617 " The string should contain one or more of the following characters:\n"
18618 " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18619 " only label the X axis, not both the X and Y axes. x: Label the X\n"
18620 " axis.\n"
18621 " y: Label the Y axis.\n"
18622 " z: Label the Z axis.\n"
18623 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18624 " For X it is the axis that starts at y-min. For Y it is the\n"
18625 " axis that starts at x-min.\n"
18626 " s: Label the secondary axis.\n"
18627 " v: Draw the text perpendicular to the axis.\n"
18628 "\n"
18629 "\n"
18630 " disp (PLFLT, input) : Position of the reference point of string,\n"
18631 " measured outwards from the specified viewport edge in units of the\n"
18632 " current character height. Use negative disp to write within the\n"
18633 " viewport.\n"
18634 "\n"
18635 " pos (PLFLT, input) : Position of the reference point of string\n"
18636 " along the specified edge, expressed as a fraction of the length of\n"
18637 " the edge.\n"
18638 "\n"
18639 " just (PLFLT, input) : Specifies the position of the string relative\n"
18640 " to its reference point. If just=0. , the reference point is at\n"
18641 " the left and if just=1. , it is at the right of the string. Other\n"
18642 " values of just give intermediate justifications.\n"
18643 "\n"
18644 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18645 " written out.\n"
18646 "\n"
18647 ""},
18648 { "plot3d", _wrap_plot3d, METH_VARARGS, "\n"
18649 "Plot 3-d surface plot\n"
18650 "\n"
18651 "DESCRIPTION:\n"
18652 "\n"
18653 " Plots a three-dimensional surface plot within the environment set up\n"
18654 " by plw3d. The surface is defined by the matrix z[\n"
18655 " nx][\n"
18656 " ny] , the point z[i][j] being the value of the function at (\n"
18657 " x[i],\n"
18658 " y[j]). Note that the points in vectors x and y do not need to be\n"
18659 " equally spaced, but must be stored in ascending order. The parameter\n"
18660 " opt controls the way in which the surface is displayed. For further\n"
18661 " details see the PLplot documentation. The only difference between\n"
18662 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18663 " while plot3d only draws the surface as viewed from the top.\n"
18664 "\n"
18665 " Redacted form: plot3d(x, y, z, opt, side)\n"
18666 "\n"
18667 " This function is used in examples 11 and 21.\n"
18668 "\n"
18669 "\n"
18670 "\n"
18671 "SYNOPSIS:\n"
18672 "\n"
18673 "plot3d(x, y, z, nx, ny, opt, side)\n"
18674 "\n"
18675 "ARGUMENTS:\n"
18676 "\n"
18677 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18678 " which the function is evaluated.\n"
18679 "\n"
18680 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18681 " which the function is evaluated.\n"
18682 "\n"
18683 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18684 " plot. Should have dimensions of\n"
18685 " nx by\n"
18686 " ny.\n"
18687 "\n"
18688 " nx (PLINT, input) : Number of x values at which function is\n"
18689 " evaluated.\n"
18690 "\n"
18691 " ny (PLINT, input) : Number of y values at which function is\n"
18692 " evaluated.\n"
18693 "\n"
18694 " opt (PLINT, input) : Determines the way in which the surface is\n"
18695 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18696 " function of x for each value of y[j] .\n"
18697 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18698 " for each value of x[i] .\n"
18699 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18700 " at which function is defined.\n"
18701 "\n"
18702 "\n"
18703 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18704 " should be draw on the figure. If side is true sides are drawn,\n"
18705 " otherwise no sides are drawn.\n"
18706 "\n"
18707 ""},
18708 { "plot3dc", _wrap_plot3dc, METH_VARARGS, "\n"
18709 "Magnitude colored plot surface with contour\n"
18710 "\n"
18711 "DESCRIPTION:\n"
18712 "\n"
18713 " Aside from dropping the\n"
18714 " side functionality this is a more powerful form of plot3d: the surface\n"
18715 " mesh can be colored accordingly to the current z value being plotted,\n"
18716 " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18717 " drawn between the plotted function border and the base XY plane. The\n"
18718 " arguments are identical to those of plmeshc. The only difference\n"
18719 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18720 " the surface, while plot3dc only draws the surface as viewed from the\n"
18721 " top.\n"
18722 "\n"
18723 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18724 "\n"
18725 "\n"
18726 " This function is used in example 21.\n"
18727 "\n"
18728 "\n"
18729 "\n"
18730 "SYNOPSIS:\n"
18731 "\n"
18732 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18733 "\n"
18734 "ARGUMENTS:\n"
18735 "\n"
18736 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18737 " which the function is evaluated.\n"
18738 "\n"
18739 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18740 " which the function is evaluated.\n"
18741 "\n"
18742 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18743 " plot. Should have dimensions of\n"
18744 " nx by\n"
18745 " ny.\n"
18746 "\n"
18747 " nx (PLINT, input) : Number of x values at which function is\n"
18748 " evaluated.\n"
18749 "\n"
18750 " ny (PLINT, input) : Number of y values at which function is\n"
18751 " evaluated.\n"
18752 "\n"
18753 " opt (PLINT, input) : Determines the way in which the surface is\n"
18754 " represented. To specify more than one option just add the options,\n"
18755 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18756 " showing z as a function of x for each value of y[j] .\n"
18757 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18758 " for each value of x[i] .\n"
18759 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18760 " at which function is defined.\n"
18761 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18762 " the z value being plotted. The color is used from the current\n"
18763 " cmap1.\n"
18764 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18765 " using parameters\n"
18766 " nlevel and\n"
18767 " clevel.\n"
18768 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18769 " the borders of the plotted function.\n"
18770 "\n"
18771 "\n"
18772 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18773 " levels.\n"
18774 "\n"
18775 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18776 "\n"
18777 ""},
18778 { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, "\n"
18779 "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18780 "\n"
18781 "DESCRIPTION:\n"
18782 "\n"
18783 " When the implementation is completed this variant of plot3dc (see that\n"
18784 " function's documentation for more details) should be suitable for the\n"
18785 " case where the area of the x, y coordinate grid where z is defined can\n"
18786 " be non-rectangular. The implementation is incomplete so the last 4\n"
18787 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18788 " indexymax; are currently ignored and the functionality is otherwise\n"
18789 " identical to that of plot3dc.\n"
18790 "\n"
18791 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18792 " indexymin, indexymax)\n"
18793 "\n"
18794 "\n"
18795 " This function is not used in any example.\n"
18796 "\n"
18797 "\n"
18798 "\n"
18799 "SYNOPSIS:\n"
18800 "\n"
18801 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18802 "\n"
18803 "ARGUMENTS:\n"
18804 "\n"
18805 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18806 " which the function is evaluated.\n"
18807 "\n"
18808 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18809 " which the function is evaluated.\n"
18810 "\n"
18811 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18812 " plot. Should have dimensions of\n"
18813 " nx by\n"
18814 " ny.\n"
18815 "\n"
18816 " nx (PLINT, input) : Number of x values at which the function is\n"
18817 " evaluated.\n"
18818 "\n"
18819 " ny (PLINT, input) : Number of y values at which the function is\n"
18820 " evaluated.\n"
18821 "\n"
18822 " opt (PLINT, input) : Determines the way in which the surface is\n"
18823 " represented. To specify more than one option just add the options,\n"
18824 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18825 " showing z as a function of x for each value of y[j] .\n"
18826 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18827 " for each value of x[i] .\n"
18828 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18829 " at which function is defined.\n"
18830 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18831 " the z value being plotted. The color is used from the current\n"
18832 " cmap1.\n"
18833 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18834 " using parameters\n"
18835 " nlevel and\n"
18836 " clevel.\n"
18837 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18838 " the borders of the plotted function.\n"
18839 "\n"
18840 "\n"
18841 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18842 " levels.\n"
18843 "\n"
18844 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18845 "\n"
18846 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18847 " corresponds to the first x index where z is defined.\n"
18848 "\n"
18849 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18850 " which corresponds (by convention) to one more than the last x\n"
18851 " index value where z is defined.\n"
18852 "\n"
18853 " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18854 " values which all must be ≥ 0. These values are the first y index\n"
18855 " where z is defined for a particular x index in the range from\n"
18856 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18857 " indexxmax.\n"
18858 "\n"
18859 " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18860 " values which all must be ≤ ny. These values correspond (by\n"
18861 " convention) to one more than the last y index where z is defined\n"
18862 " for a particular x index in the range from indexxmin to indexxmax\n"
18863 " - 1. The dimension of indexymax is indexxmax.\n"
18864 "\n"
18865 ""},
18866 { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, "\n"
18867 "Plot shaded 3-d surface plot\n"
18868 "\n"
18869 "DESCRIPTION:\n"
18870 "\n"
18871 " Plots a three-dimensional shaded surface plot within the environment\n"
18872 " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18873 " z[\n"
18874 " nx][\n"
18875 " ny], the point z[i][j] being the value of the function at (\n"
18876 " x[i],\n"
18877 " y[j]). Note that the points in vectors x and y do not need to be\n"
18878 " equally spaced, but must be stored in ascending order. For further\n"
18879 " details see the PLplot documentation.\n"
18880 "\n"
18881 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18882 "\n"
18883 " This function is not used in any examples.\n"
18884 "\n"
18885 "\n"
18886 "\n"
18887 "SYNOPSIS:\n"
18888 "\n"
18889 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18890 "\n"
18891 "ARGUMENTS:\n"
18892 "\n"
18893 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18894 " which the function is evaluated.\n"
18895 "\n"
18896 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18897 " which the function is evaluated.\n"
18898 "\n"
18899 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18900 " plot. Should have dimensions of\n"
18901 " nx by\n"
18902 " ny.\n"
18903 "\n"
18904 " nx (PLINT, input) : Number of x values at which function is\n"
18905 " evaluated.\n"
18906 "\n"
18907 " ny (PLINT, input) : Number of y values at which function is\n"
18908 " evaluated.\n"
18909 "\n"
18910 " opt (PLINT, input) : Determines the way in which the surface is\n"
18911 " represented. To specify more than one option just add the options,\n"
18912 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18913 " connecting points at which function is defined.\n"
18914 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18915 " using parameters\n"
18916 " nlevel and\n"
18917 " clevel.\n"
18918 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18919 " using parameters\n"
18920 " nlevel and\n"
18921 " clevel.\n"
18922 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18923 " the borders of the plotted function.\n"
18924 " opt=MAG_COLOR : the surface is colored according to the value\n"
18925 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18926 " according to the intensity of the reflected light in the\n"
18927 " surface from a light source whose position is set using\n"
18928 " pllightsource.\n"
18929 "\n"
18930 "\n"
18931 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18932 " levels.\n"
18933 "\n"
18934 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18935 "\n"
18936 ""},
18937 { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, "\n"
18938 "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18939 "\n"
18940 "DESCRIPTION:\n"
18941 "\n"
18942 " This variant of plsurf3d (see that function's documentation for more\n"
18943 " details) should be suitable for the case where the area of the x, y\n"
18944 " coordinate grid where z is defined can be non-rectangular. The limits\n"
18945 " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18946 " indexymin, and indexymax.\n"
18947 "\n"
18948 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18949 " indexymax)\n"
18950 "\n"
18951 " This function is used in example 8.\n"
18952 "\n"
18953 "\n"
18954 "\n"
18955 "SYNOPSIS:\n"
18956 "\n"
18957 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18958 "\n"
18959 "ARGUMENTS:\n"
18960 "\n"
18961 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18962 " which the function is evaluated.\n"
18963 "\n"
18964 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18965 " which the function is evaluated.\n"
18966 "\n"
18967 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18968 " plot. Should have dimensions of\n"
18969 " nx by\n"
18970 " ny.\n"
18971 "\n"
18972 " nx (PLINT, input) : Number of x values at which function is\n"
18973 " evaluated.\n"
18974 "\n"
18975 " ny (PLINT, input) : Number of y values at which function is\n"
18976 " evaluated.\n"
18977 "\n"
18978 " opt (PLINT, input) : Determines the way in which the surface is\n"
18979 " represented. To specify more than one option just add the options,\n"
18980 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18981 " connecting points at which function is defined.\n"
18982 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18983 " using parameters\n"
18984 " nlevel and\n"
18985 " clevel.\n"
18986 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18987 " using parameters\n"
18988 " nlevel and\n"
18989 " clevel.\n"
18990 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18991 " the borders of the plotted function.\n"
18992 " opt=MAG_COLOR : the surface is colored according to the value\n"
18993 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18994 " according to the intensity of the reflected light in the\n"
18995 " surface from a light source whose position is set using\n"
18996 " pllightsource.\n"
18997 "\n"
18998 "\n"
18999 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
19000 " levels.\n"
19001 "\n"
19002 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
19003 "\n"
19004 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
19005 " corresponds to the first x index where z is defined.\n"
19006 "\n"
19007 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
19008 " which corresponds (by convention) to one more than the last x\n"
19009 " index value where z is defined.\n"
19010 "\n"
19011 " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
19012 " values which all must be ≥ 0. These values are the first y index\n"
19013 " where z is defined for a particular x index in the range from\n"
19014 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
19015 " indexxmax.\n"
19016 "\n"
19017 " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
19018 " values which all must be ≤ ny. These values correspond (by\n"
19019 " convention) to one more than the last y index where z is defined\n"
19020 " for a particular x index in the range from indexxmin to indexxmax\n"
19021 " - 1. The dimension of indexymax is indexxmax.\n"
19022 "\n"
19023 ""},
19024 { "plparseopts", _wrap_plparseopts, METH_VARARGS, "\n"
19025 "Parse command-line arguments\n"
19026 "\n"
19027 "DESCRIPTION:\n"
19028 "\n"
19029 " Parse command-line arguments.\n"
19030 "\n"
19031 " plparseopts removes all recognized flags (decreasing argc\n"
19032 " accordingly), so that invalid input may be readily detected. It can\n"
19033 " also be used to process user command line flags. The user can merge\n"
19034 " an option table of type PLOptionTable into the internal option table\n"
19035 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
19036 " the external table(s) be parsed by calling plClearOpts before\n"
19037 " plMergeOpts.\n"
19038 "\n"
19039 " The default action taken by plparseopts is as follows:\n"
19040 " Returns with an error if an unrecognized option or badly formed\n"
19041 " option-value pair are encountered.\n"
19042 " Returns immediately (return code 0) when the first non-option command\n"
19043 " line argument is found.\n"
19044 " Returns with the return code of the option handler, if one was called.\n"
19045 "\n"
19046 " Deletes command line arguments from argv list as they are found, and\n"
19047 " decrements argc accordingly.\n"
19048 " Does not show \"invisible\" options in usage or help messages.\n"
19049 " Assumes the program name is contained in argv[0].\n"
19050 "\n"
19051 " These behaviors may be controlled through the\n"
19052 " mode argument.\n"
19053 "\n"
19054 " Redacted form: General: plparseopts(argv, mode)\n"
19055 "\n"
19056 "\n"
19057 " This function is used in all of the examples.\n"
19058 "\n"
19059 "\n"
19060 "\n"
19061 "SYNOPSIS:\n"
19062 "\n"
19063 "PLINT plparseopts(p_argc, argv, mode)\n"
19064 "\n"
19065 "ARGUMENTS:\n"
19066 "\n"
19067 " p_argc (int *, input/output) : Number of arguments.\n"
19068 "\n"
19069 " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
19070 " strings containing *p_argc command-line arguments.\n"
19071 "\n"
19072 " mode (PLINT, input) : Parsing mode with the following\n"
19073 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
19074 " and all error messages enabled, including program exit when an\n"
19075 " error occurs. Anything on the command line that isn't recognized\n"
19076 " as a valid option or option argument is flagged as an error.\n"
19077 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
19078 " of errors.\n"
19079 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
19080 " arguments.\n"
19081 " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
19082 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
19083 " pointer to the program name.\n"
19084 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
19085 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
19086 " unrecognized arguments.\n"
19087 "\n"
19088 ""},
19089 { "plpat", _wrap_plpat, METH_VARARGS, "\n"
19090 "Set area line fill pattern\n"
19091 "\n"
19092 "DESCRIPTION:\n"
19093 "\n"
19094 " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
19095 " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
19096 " inclinations and spacings. The arguments to this routine are the\n"
19097 " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
19098 " elements) specifying the inclinations in tenths of a degree and the\n"
19099 " spacing in micrometers. (See also plpsty)\n"
19100 "\n"
19101 " Redacted form: General: plpat(inc, del)\n"
19102 "\n"
19103 "\n"
19104 " This function is used in example 15.\n"
19105 "\n"
19106 "\n"
19107 "\n"
19108 "SYNOPSIS:\n"
19109 "\n"
19110 "plpat(nlin, inc, del)\n"
19111 "\n"
19112 "ARGUMENTS:\n"
19113 "\n"
19114 " nlin (PLINT, input) : Number of sets of lines making up the\n"
19115 " pattern, either 1 or 2.\n"
19116 "\n"
19117 " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19118 " inclination in tenths of a degree. (Should be between -900 and\n"
19119 " 900).\n"
19120 "\n"
19121 " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19122 " spacing in micrometers between the lines making up the pattern.\n"
19123 "\n"
19124 ""},
19125 { "plpath", _wrap_plpath, METH_VARARGS, "\n"
19126 "Draw a line between two points, accounting for coordinate transforms\n"
19127 "\n"
19128 "DESCRIPTION:\n"
19129 "\n"
19130 " Joins the point (\n"
19131 " x1,\n"
19132 " y1) to (\n"
19133 " x2,\n"
19134 " y2) . If a global coordinate transform is defined then the line is\n"
19135 " broken in to n segments to approximate the path. If no transform is\n"
19136 " defined then this simply acts like a call to pljoin.\n"
19137 "\n"
19138 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
19139 "\n"
19140 " This function is used in example 22.\n"
19141 "\n"
19142 "\n"
19143 "\n"
19144 "SYNOPSIS:\n"
19145 "\n"
19146 "plpath(n, x1, y1, x2, y2)\n"
19147 "\n"
19148 "ARGUMENTS:\n"
19149 "\n"
19150 " n (PLINT, input) : number of points to use to approximate the path.\n"
19151 "\n"
19152 " x1 (PLFLT, input) : x coordinate of first point.\n"
19153 "\n"
19154 " y1 (PLFLT, input) : y coordinate of first point.\n"
19155 "\n"
19156 " x2 (PLFLT, input) : x coordinate of second point.\n"
19157 "\n"
19158 " y2 (PLFLT, input) : y coordinate of second point.\n"
19159 "\n"
19160 ""},
19161 { "plpoin", _wrap_plpoin, METH_VARARGS, "\n"
19162 "Plot a glyph at the specified points\n"
19163 "\n"
19164 "DESCRIPTION:\n"
19165 "\n"
19166 " Plot a glyph at the specified points. (This function is largely\n"
19167 " superseded by plstring which gives access to many[!] more glyphs.)\n"
19168 " code=-1 means try to just draw a point. Right now it's just a move\n"
19169 " and a draw at the same place. Not ideal, since a sufficiently\n"
19170 " intelligent output device may optimize it away, or there may be faster\n"
19171 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19172 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19173 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19174 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19175 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19176 "\n"
19177 " Redacted form: plpoin(x, y, code)\n"
19178 "\n"
19179 " This function is used in examples 1, 6, 14, and 29.\n"
19180 "\n"
19181 "\n"
19182 "\n"
19183 "SYNOPSIS:\n"
19184 "\n"
19185 "plpoin(n, x, y, code)\n"
19186 "\n"
19187 "ARGUMENTS:\n"
19188 "\n"
19189 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19190 "\n"
19191 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19192 " points.\n"
19193 "\n"
19194 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19195 " points.\n"
19196 "\n"
19197 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19198 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19199 " each of the n points.\n"
19200 "\n"
19201 ""},
19202 { "plpoin3", _wrap_plpoin3, METH_VARARGS, "\n"
19203 "Plot a glyph at the specified 3D points\n"
19204 "\n"
19205 "DESCRIPTION:\n"
19206 "\n"
19207 " Plot a glyph at the specified 3D points. (This function is largely\n"
19208 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
19209 " Set up the call to this function similar to what is done for plline3.\n"
19210 " code=-1 means try to just draw a point. Right now it's just a move\n"
19211 " and a draw at the same place. Not ideal, since a sufficiently\n"
19212 " intelligent output device may optimize it away, or there may be faster\n"
19213 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19214 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19215 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19216 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19217 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19218 "\n"
19219 " Redacted form: plpoin3(x, y, z, code)\n"
19220 "\n"
19221 " This function is not used in any example.\n"
19222 "\n"
19223 "\n"
19224 "\n"
19225 "SYNOPSIS:\n"
19226 "\n"
19227 "plpoin3(n, x, y, z, code)\n"
19228 "\n"
19229 "ARGUMENTS:\n"
19230 "\n"
19231 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19232 "\n"
19233 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19234 " points.\n"
19235 "\n"
19236 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19237 " points.\n"
19238 "\n"
19239 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
19240 " points.\n"
19241 "\n"
19242 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19243 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19244 " each of the n points.\n"
19245 "\n"
19246 ""},
19247 { "plpoly3", _wrap_plpoly3, METH_VARARGS, "\n"
19248 "Draw a polygon in 3 space\n"
19249 "\n"
19250 "DESCRIPTION:\n"
19251 "\n"
19252 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19253 " like plline3, but differs from that function in that plpoly3 attempts\n"
19254 " to determine if the polygon is viewable depending on the order of the\n"
19255 " points within the vector and the value of ifcc. If the back of\n"
19256 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19257 " you want, then use plline3 instead.\n"
19258 "\n"
19259 " The points are assumed to be in a plane, and the directionality of the\n"
19260 " plane is determined from the first three points. Additional points do\n"
19261 " not have to lie on the plane defined by the first three, but if they\n"
19262 " do not, then the determination of visibility obviously can't be 100%\n"
19263 " accurate... So if you're 3 space polygons are too far from planar,\n"
19264 " consider breaking them into smaller polygons. 3 points define a plane\n"
19265 " :-).\n"
19266 "\n"
19267 " Bugs: If one of the first two segments is of zero length, or if they\n"
19268 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19269 " being correct. Avoid such situations :-). See x18c.c for an example\n"
19270 " of this problem. (Search for 20.1).\n"
19271 "\n"
19272 " Redacted form: plpoly3(x, y, z, code)\n"
19273 "\n"
19274 " This function is used in example 18.\n"
19275 "\n"
19276 "\n"
19277 "\n"
19278 "SYNOPSIS:\n"
19279 "\n"
19280 "plpoly3(n, x, y, z, draw, ifcc)\n"
19281 "\n"
19282 "ARGUMENTS:\n"
19283 "\n"
19284 " n (PLINT, input) : Number of points defining line.\n"
19285 "\n"
19286 " x (PLFLT_VECTOR, input) : A vector containing\n"
19287 " n x coordinates of points.\n"
19288 "\n"
19289 " y (PLFLT_VECTOR, input) : A vector containing\n"
19290 " n y coordinates of points.\n"
19291 "\n"
19292 " z (PLFLT_VECTOR, input) : A vector containing\n"
19293 " n z coordinates of points.\n"
19294 "\n"
19295 " draw (PLBOOL_VECTOR, input) : A vector containing\n"
19296 " n-1 Boolean values which control drawing the segments of the polygon.\n"
19297 " If draw[i] is true, then the polygon segment from index [i] to\n"
19298 " [i+1] is drawn, otherwise, not.\n"
19299 "\n"
19300 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19301 " polygon is determined by assuming the points are laid out in a\n"
19302 " counter-clockwise order. Otherwise, the directionality of the\n"
19303 " polygon is determined by assuming the points are laid out in a\n"
19304 " clockwise order.\n"
19305 "\n"
19306 ""},
19307 { "plprec", _wrap_plprec, METH_VARARGS, "\n"
19308 "Set precision in numeric labels\n"
19309 "\n"
19310 "DESCRIPTION:\n"
19311 "\n"
19312 " Sets the number of places after the decimal point in numeric labels.\n"
19313 "\n"
19314 " Redacted form: plprec(setp, prec)\n"
19315 "\n"
19316 " This function is used in example 29.\n"
19317 "\n"
19318 "\n"
19319 "\n"
19320 "SYNOPSIS:\n"
19321 "\n"
19322 "plprec(setp, prec)\n"
19323 "\n"
19324 "ARGUMENTS:\n"
19325 "\n"
19326 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19327 " automatically determines the number of places to use after the\n"
19328 " decimal point in numeric labels (like those used to label axes).\n"
19329 " If setp is 1 then prec sets the number of places.\n"
19330 "\n"
19331 " prec (PLINT, input) : The number of characters to draw after the\n"
19332 " decimal point in numeric labels.\n"
19333 "\n"
19334 ""},
19335 { "plpsty", _wrap_plpsty, METH_O, "\n"
19336 "Select area fill pattern\n"
19337 "\n"
19338 "DESCRIPTION:\n"
19339 "\n"
19340 " If\n"
19341 " patt is zero or less use either a hardware solid fill if the drivers\n"
19342 " have that capability (virtually all do) or fall back to a software\n"
19343 " emulation of a solid fill using the eighth area line fill pattern. If\n"
19344 " 0 <\n"
19345 " patt <= 8, then select one of eight predefined area line fill patterns\n"
19346 " to use (see plpat if you desire other patterns).\n"
19347 "\n"
19348 " Redacted form: plpsty(patt)\n"
19349 "\n"
19350 " This function is used in examples 12, 13, 15, 16, and 25.\n"
19351 "\n"
19352 "\n"
19353 "\n"
19354 "SYNOPSIS:\n"
19355 "\n"
19356 "plpsty(patt)\n"
19357 "\n"
19358 "ARGUMENTS:\n"
19359 "\n"
19360 " patt (PLINT, input) : The desired pattern index. If\n"
19361 " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
19362 " above) used. For\n"
19363 " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
19364 " line fill capability itself (most deliberately do not so that line\n"
19365 " fill patterns look identical for those drivers), the patterns\n"
19366 " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
19367 " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
19368 " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
19369 " (8) lines at both 45 degrees and -45 degrees.\n"
19370 "\n"
19371 ""},
19372 { "plptex", _wrap_plptex, METH_VARARGS, "\n"
19373 "Write text inside the viewport\n"
19374 "\n"
19375 "DESCRIPTION:\n"
19376 "\n"
19377 " Writes text at a specified position and inclination within the\n"
19378 " viewport. Text is clipped at the viewport boundaries. The reference\n"
19379 " point of a string lies along a line passing through the string at half\n"
19380 " the height of a capital letter. The position of the reference point\n"
19381 " along this line is determined by just, the reference point is placed\n"
19382 " at world coordinates (\n"
19383 " x,\n"
19384 " y) within the viewport. The inclination of the string is specified\n"
19385 " in terms of differences of world coordinates making it easy to write\n"
19386 " text parallel to a line in a graph.\n"
19387 "\n"
19388 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19389 "\n"
19390 " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
19391 "\n"
19392 "\n"
19393 "\n"
19394 "SYNOPSIS:\n"
19395 "\n"
19396 "plptex(x, y, dx, dy, just, text)\n"
19397 "\n"
19398 "ARGUMENTS:\n"
19399 "\n"
19400 " x (PLFLT, input) : x coordinate of reference point of string.\n"
19401 "\n"
19402 " y (PLFLT, input) : y coordinate of reference point of string.\n"
19403 "\n"
19404 " dx (PLFLT, input) : Together with dy, this specifies the\n"
19405 " inclination of the string. The baseline of the string is parallel\n"
19406 " to a line joining (\n"
19407 " x,\n"
19408 " y) to (\n"
19409 " x+\n"
19410 " dx,\n"
19411 " y+\n"
19412 " dy) .\n"
19413 "\n"
19414 " dy (PLFLT, input) : Together with dx, this specifies the\n"
19415 " inclination of the string.\n"
19416 "\n"
19417 " just (PLFLT, input) : Specifies the position of the string relative\n"
19418 " to its reference point. If just=0. , the reference point is at\n"
19419 " the left and if just=1. , it is at the right of the string. Other\n"
19420 " values of just give intermediate justifications.\n"
19421 "\n"
19422 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19423 " written out.\n"
19424 "\n"
19425 ""},
19426 { "plptex3", _wrap_plptex3, METH_VARARGS, "\n"
19427 "Write text inside the viewport of a 3D plot\n"
19428 "\n"
19429 "DESCRIPTION:\n"
19430 "\n"
19431 " Writes text at a specified position and inclination and with a\n"
19432 " specified shear within the viewport. Text is clipped at the viewport\n"
19433 " boundaries. The reference point of a string lies along a line passing\n"
19434 " through the string at half the height of a capital letter. The\n"
19435 " position of the reference point along this line is determined by just,\n"
19436 " and the reference point is placed at world coordinates (\n"
19437 " wx,\n"
19438 " wy,\n"
19439 " wz) within the viewport. The inclination and shear of the string is\n"
19440 " specified in terms of differences of world coordinates making it easy\n"
19441 " to write text parallel to a line in a graph.\n"
19442 "\n"
19443 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19444 "\n"
19445 " This function is used in example 28.\n"
19446 "\n"
19447 "\n"
19448 "\n"
19449 "SYNOPSIS:\n"
19450 "\n"
19451 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19452 "\n"
19453 "ARGUMENTS:\n"
19454 "\n"
19455 " wx (PLFLT, input) : x world coordinate of reference point of\n"
19456 " string.\n"
19457 "\n"
19458 " wy (PLFLT, input) : y world coordinate of reference point of\n"
19459 " string.\n"
19460 "\n"
19461 " wz (PLFLT, input) : z world coordinate of reference point of\n"
19462 " string.\n"
19463 "\n"
19464 " dx (PLFLT, input) : Together with dy and\n"
19465 " dz , this specifies the inclination of the string. The baseline of\n"
19466 " the string is parallel to a line joining (\n"
19467 " x,\n"
19468 " y,\n"
19469 " z) to (\n"
19470 " x+\n"
19471 " dx,\n"
19472 " y+\n"
19473 " dy,\n"
19474 " z+\n"
19475 " dz) .\n"
19476 "\n"
19477 " dy (PLFLT, input) : Together with dx and\n"
19478 " dz, this specifies the inclination of the string.\n"
19479 "\n"
19480 " dz (PLFLT, input) : Together with dx and\n"
19481 " dy, this specifies the inclination of the string.\n"
19482 "\n"
19483 " sx (PLFLT, input) : Together with sy and\n"
19484 " sz , this specifies the shear of the string. The string is sheared so\n"
19485 " that the characters are vertically parallel to a line joining (\n"
19486 " x,\n"
19487 " y,\n"
19488 " z) to (\n"
19489 " x+\n"
19490 " sx,\n"
19491 " y+\n"
19492 " sy,\n"
19493 " z+\n"
19494 " sz) . If sx =\n"
19495 " sy =\n"
19496 " sz = 0.) then the text is not sheared.\n"
19497 "\n"
19498 " sy (PLFLT, input) : Together with sx and\n"
19499 " sz, this specifies shear of the string.\n"
19500 "\n"
19501 " sz (PLFLT, input) : Together with sx and\n"
19502 " sy, this specifies shear of the string.\n"
19503 "\n"
19504 " just (PLFLT, input) : Specifies the position of the string relative\n"
19505 " to its reference point. If just=0. , the reference point is at\n"
19506 " the left and if just=1. , it is at the right of the string. Other\n"
19507 " values of just give intermediate justifications.\n"
19508 "\n"
19509 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19510 " written out.\n"
19511 "\n"
19512 ""},
19513 { "plrandd", _wrap_plrandd, METH_NOARGS, "\n"
19514 "Random number generator returning a real random number in the range [0,1]\n"
19515 "\n"
19516 "DESCRIPTION:\n"
19517 "\n"
19518 " Random number generator returning a real random number in the range\n"
19519 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19520 " / compilers provide their own random number generator, and so this is\n"
19521 " provided purely for convenience and to give a consistent random number\n"
19522 " generator across all languages supported by PLplot. This is\n"
19523 " particularly useful for comparing results from the test suite of\n"
19524 " examples.\n"
19525 "\n"
19526 " Redacted form: plrandd()\n"
19527 "\n"
19528 " This function is used in examples 17 and 21.\n"
19529 "\n"
19530 "\n"
19531 "\n"
19532 "SYNOPSIS:\n"
19533 "\n"
19534 "plrandd()\n"
19535 "\n"
19536 ""},
19537 { "plreplot", _wrap_plreplot, METH_NOARGS, "\n"
19538 "Replays contents of plot buffer to current device/file\n"
19539 "\n"
19540 "DESCRIPTION:\n"
19541 "\n"
19542 " Replays contents of plot buffer to current device/file.\n"
19543 "\n"
19544 " Redacted form: plreplot()\n"
19545 "\n"
19546 " This function is used in example 1,20.\n"
19547 "\n"
19548 "\n"
19549 "\n"
19550 "SYNOPSIS:\n"
19551 "\n"
19552 "plreplot()\n"
19553 "\n"
19554 ""},
19555 { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, "\n"
19556 "Convert RGB color to HLS\n"
19557 "\n"
19558 "DESCRIPTION:\n"
19559 "\n"
19560 " Convert RGB color coordinates to HLS\n"
19561 "\n"
19562 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19563 "\n"
19564 "\n"
19565 " This function is used in example 2.\n"
19566 "\n"
19567 "\n"
19568 "\n"
19569 "SYNOPSIS:\n"
19570 "\n"
19571 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19572 "\n"
19573 "ARGUMENTS:\n"
19574 "\n"
19575 " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19576 "\n"
19577 " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19578 "\n"
19579 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19580 "\n"
19581 " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19582 " degrees (0.0-360.0) on the color cylinder.\n"
19583 "\n"
19584 " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19585 " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19586 " cylinder.\n"
19587 "\n"
19588 " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19589 " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19590 " cylinder.\n"
19591 "\n"
19592 ""},
19593 { "plschr", _wrap_plschr, METH_VARARGS, "\n"
19594 "Set character size\n"
19595 "\n"
19596 "DESCRIPTION:\n"
19597 "\n"
19598 " This sets up the size of all subsequent characters drawn. The actual\n"
19599 " height of a character is the product of the default character size and\n"
19600 " a scaling factor.\n"
19601 "\n"
19602 " Redacted form: plschr(def, scale)\n"
19603 "\n"
19604 " This function is used in examples 2, 13, 23, and 24.\n"
19605 "\n"
19606 "\n"
19607 "\n"
19608 "SYNOPSIS:\n"
19609 "\n"
19610 "plschr(def, scale)\n"
19611 "\n"
19612 "ARGUMENTS:\n"
19613 "\n"
19614 " def (PLFLT, input) : The default height of a character in\n"
19615 " millimeters, should be set to zero if the default height is to\n"
19616 " remain unchanged. For rasterized drivers the dx and dy values\n"
19617 " specified in plspage are used to convert from mm to pixels (note\n"
19618 " the different unit systems used). This dpi aware scaling is not\n"
19619 " implemented for all drivers yet.\n"
19620 "\n"
19621 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19622 " actual character height.\n"
19623 "\n"
19624 ""},
19625 { "plscmap0", _wrap_plscmap0, METH_VARARGS, "\n"
19626 "Set cmap0 colors by 8-bit RGB values\n"
19627 "\n"
19628 "DESCRIPTION:\n"
19629 "\n"
19630 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19631 " documentation). This sets the entire color map -- only as many colors\n"
19632 " as specified will be allocated.\n"
19633 "\n"
19634 " Redacted form: plscmap0(r, g, b)\n"
19635 "\n"
19636 " This function is used in examples 2 and 24.\n"
19637 "\n"
19638 "\n"
19639 "\n"
19640 "SYNOPSIS:\n"
19641 "\n"
19642 "plscmap0(r, g, b, ncol0)\n"
19643 "\n"
19644 "ARGUMENTS:\n"
19645 "\n"
19646 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19647 " integers (0-255) representing the degree of red in the color.\n"
19648 "\n"
19649 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19650 " integers (0-255) representing the degree of green in the color.\n"
19651 "\n"
19652 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19653 " integers (0-255) representing the degree of blue in the color.\n"
19654 "\n"
19655 " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19656 "\n"
19657 ""},
19658 { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, "\n"
19659 "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19660 "\n"
19661 "DESCRIPTION:\n"
19662 "\n"
19663 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19664 " and PLFLT alpha transparency value. This sets the entire color map --\n"
19665 " only as many colors as specified will be allocated.\n"
19666 "\n"
19667 " Redacted form: plscmap0a(r, g, b, alpha)\n"
19668 "\n"
19669 " This function is used in examples 30.\n"
19670 "\n"
19671 "\n"
19672 "\n"
19673 "SYNOPSIS:\n"
19674 "\n"
19675 "plscmap0a(r, g, b, alpha, ncol0)\n"
19676 "\n"
19677 "ARGUMENTS:\n"
19678 "\n"
19679 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19680 " integers (0-255) representing the degree of red in the color.\n"
19681 "\n"
19682 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19683 " integers (0-255) representing the degree of green in the color.\n"
19684 "\n"
19685 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19686 " integers (0-255) representing the degree of blue in the color.\n"
19687 "\n"
19688 " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19689 " representing the alpha transparency of the color.\n"
19690 "\n"
19691 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19692 " vectors.\n"
19693 "\n"
19694 ""},
19695 { "plscmap0n", _wrap_plscmap0n, METH_O, "\n"
19696 "Set number of colors in cmap0\n"
19697 "\n"
19698 "DESCRIPTION:\n"
19699 "\n"
19700 " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19701 " (or reallocate) cmap0, and fill with default values for those colors\n"
19702 " not previously allocated. The first 16 default colors are given in\n"
19703 " the plcol0 documentation. For larger indices the default color is\n"
19704 " red.\n"
19705 "\n"
19706 " The drivers are not guaranteed to support more than 16 colors.\n"
19707 "\n"
19708 " Redacted form: plscmap0n(ncol0)\n"
19709 "\n"
19710 " This function is used in examples 15, 16, and 24.\n"
19711 "\n"
19712 "\n"
19713 "\n"
19714 "SYNOPSIS:\n"
19715 "\n"
19716 "plscmap0n(ncol0)\n"
19717 "\n"
19718 "ARGUMENTS:\n"
19719 "\n"
19720 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19721 " the cmap0 palette. If this number is zero or less, then the value\n"
19722 " from the previous call to plscmap0n is used and if there is no\n"
19723 " previous call, then a default value is used.\n"
19724 "\n"
19725 ""},
19726 { "plscmap1", _wrap_plscmap1, METH_VARARGS, "\n"
19727 "Set opaque RGB cmap1 colors values\n"
19728 "\n"
19729 "DESCRIPTION:\n"
19730 "\n"
19731 " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19732 " vector values. This function also sets the number of cmap1 colors.\n"
19733 " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19734 " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19735 " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19736 " to\n"
19737 " ncol1-1. So in order for this continuous color model to work\n"
19738 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19739 " that these RGB vectors are continuous functions of their integer\n"
19740 " indices.\n"
19741 "\n"
19742 " Redacted form: plscmap1(r, g, b)\n"
19743 "\n"
19744 " This function is used in example 31.\n"
19745 "\n"
19746 "\n"
19747 "\n"
19748 "SYNOPSIS:\n"
19749 "\n"
19750 "plscmap1(r, g, b, ncol1)\n"
19751 "\n"
19752 "ARGUMENTS:\n"
19753 "\n"
19754 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19755 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19756 " color as a continuous function of the integer index of the vector.\n"
19757 "\n"
19758 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19759 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19760 " color as a continuous function of the integer index of the vector.\n"
19761 "\n"
19762 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19763 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19764 " color as a continuous function of the integer index of the vector.\n"
19765 "\n"
19766 " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19767 "\n"
19768 ""},
19769 { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, "\n"
19770 "Set semitransparent cmap1 RGBA colors.\n"
19771 "\n"
19772 "DESCRIPTION:\n"
19773 "\n"
19774 " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19775 " RGBA vector values. This function also sets the number of cmap1\n"
19776 " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19777 " floating-point index in the range from 0.0-1.0 which is linearly\n"
19778 " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19779 " vectors in the range from 0 to\n"
19780 " ncol1-1. So in order for this continuous color model to work\n"
19781 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19782 " that these RGBA vectors are continuous functions of their integer\n"
19783 " indices.\n"
19784 "\n"
19785 " Redacted form: plscmap1a(r, g, b, alpha)\n"
19786 "\n"
19787 " This function is used in example 31.\n"
19788 "\n"
19789 "\n"
19790 "\n"
19791 "SYNOPSIS:\n"
19792 "\n"
19793 "plscmap1a(r, g, b, alpha, ncol1)\n"
19794 "\n"
19795 "ARGUMENTS:\n"
19796 "\n"
19797 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19798 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19799 " color as a continuous function of the integer index of the vector.\n"
19800 "\n"
19801 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19802 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19803 " color as a continuous function of the integer index of the vector.\n"
19804 "\n"
19805 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19806 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19807 " color as a continuous function of the integer index of the vector.\n"
19808 "\n"
19809 " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19810 " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19811 " completely transparent and 1.0 corresponds to completely opaque)\n"
19812 " the alpha transparency of the color as a continuous function of\n"
19813 " the integer index of the vector.\n"
19814 "\n"
19815 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19816 " vectors.\n"
19817 "\n"
19818 ""},
19819 { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, "\n"
19820 "Set cmap1 colors using a piece-wise linear relationship\n"
19821 "\n"
19822 "DESCRIPTION:\n"
19823 "\n"
19824 " Set cmap1 colors using a piece-wise linear relationship between the\n"
19825 " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19826 " (see the PLplot documentation). May be called at any time.\n"
19827 "\n"
19828 " The idea here is to specify a number of control points that define the\n"
19829 " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19830 " these points, linear interpolation is used which gives a smooth\n"
19831 " variation of color with intensity index. Any number of control points\n"
19832 " may be specified, located at arbitrary positions, although typically 2\n"
19833 " - 4 are enough. Another way of stating this is that we are traversing\n"
19834 " a given number of lines through HLS or RGB space as we move through\n"
19835 " cmap1 intensity indices. The control points at the minimum and\n"
19836 " maximum position (0 and 1) must always be specified. By adding more\n"
19837 " control points you can get more variation. One good technique for\n"
19838 " plotting functions that vary about some expected average is to use an\n"
19839 " additional 2 control points in the center (position ~= 0.5) that are\n"
19840 " the same lightness as the background (typically white for paper\n"
19841 " output, black for crt), and same hue as the boundary control points.\n"
19842 " This allows the highs and lows to be very easily distinguished.\n"
19843 "\n"
19844 " Each control point must specify the cmap1 intensity index and the\n"
19845 " associated three coordinates in HLS or RGB space. The first point\n"
19846 " must correspond to position = 0, and the last to position = 1.\n"
19847 "\n"
19848 " If RGB colors are provided then the interpolation takes place in RGB\n"
19849 " space and is trivial. However if HLS colors are provided then, because\n"
19850 " of the circular nature of the color wheel for the hue coordinate, the\n"
19851 " interpolation could be performed in either direction around the color\n"
19852 " wheel. The default behaviour is for the hue to be linearly\n"
19853 " interpolated ignoring this circular property of hue. So for example,\n"
19854 " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19855 " green and cyan. If instead you wish to interpolate the other way\n"
19856 " around the color wheel you have two options. You may provide hues\n"
19857 " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19858 " for red the interpolation will proceed via magenta. Alternatively you\n"
19859 " can utilise the alt_hue_path variable to reverse the direction of\n"
19860 " interpolation if you need to provide hues within the [0-360) range.\n"
19861 "\n"
19862 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19863 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19864 " -120]falsegreen-yellow-red-magenta-blue[240\n"
19865 " 480]falseblue-magenta-red-yellow-green[120\n"
19866 " 240]truegreen-yellow-red-magenta-blue[240\n"
19867 " 120]trueblue-magenta-red-yellow-green\n"
19868 "\n"
19869 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19870 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19871 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19872 "\n"
19873 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19874 " alt_hue_path)\n"
19875 "\n"
19876 " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19877 "\n"
19878 "\n"
19879 "\n"
19880 "SYNOPSIS:\n"
19881 "\n"
19882 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19883 "\n"
19884 "ARGUMENTS:\n"
19885 "\n"
19886 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19887 "\n"
19888 " npts (PLINT, input) : number of control points\n"
19889 "\n"
19890 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19891 " intensity index (0.0-1.0) in ascending order for each control\n"
19892 " point.\n"
19893 "\n"
19894 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19895 " coordinate (H or R) for each control point.\n"
19896 "\n"
19897 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19898 " coordinate (L or G) for each control point.\n"
19899 "\n"
19900 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19901 " coordinate (S or B) for each control point.\n"
19902 "\n"
19903 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19904 " npts - 1 elements), each containing either true to use the reversed\n"
19905 " HLS interpolation or false to use the regular HLS interpolation.\n"
19906 " (alt_hue_path[i] refers to the interpolation interval between the\n"
19907 " i and i + 1 control points). This parameter is not used for RGB\n"
19908 " colors (\n"
19909 " itype = true).\n"
19910 "\n"
19911 ""},
19912 { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, "\n"
19913 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19914 "\n"
19915 "DESCRIPTION:\n"
19916 "\n"
19917 " This is a variant of plscmap1l that supports alpha channel\n"
19918 " transparency. It sets cmap1 colors using a piece-wise linear\n"
19919 " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19920 " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19921 " transparency value (0.0-1.0). It may be called at any time.\n"
19922 "\n"
19923 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19924 " alpha, alt_hue_path)\n"
19925 "\n"
19926 " This function is used in example 30.\n"
19927 "\n"
19928 "\n"
19929 "\n"
19930 "SYNOPSIS:\n"
19931 "\n"
19932 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19933 "\n"
19934 "ARGUMENTS:\n"
19935 "\n"
19936 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19937 "\n"
19938 " npts (PLINT, input) : number of control points.\n"
19939 "\n"
19940 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19941 " intensity index (0.0-1.0) in ascending order for each control\n"
19942 " point.\n"
19943 "\n"
19944 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19945 " coordinate (H or R) for each control point.\n"
19946 "\n"
19947 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19948 " coordinate (L or G) for each control point.\n"
19949 "\n"
19950 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19951 " coordinate (S or B) for each control point.\n"
19952 "\n"
19953 " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19954 " transparency value (0.0-1.0) for each control point.\n"
19955 "\n"
19956 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19957 " npts - 1 elements) containing the alternative interpolation method\n"
19958 " Boolean value for each control point interval. (alt_hue_path[i]\n"
19959 " refers to the interpolation interval between the i and i + 1\n"
19960 " control points).\n"
19961 "\n"
19962 ""},
19963 { "plscmap1n", _wrap_plscmap1n, METH_O, "\n"
19964 "Set number of colors in cmap1\n"
19965 "\n"
19966 "DESCRIPTION:\n"
19967 "\n"
19968 " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19969 " values if this is the first allocation (see the PLplot documentation).\n"
19970 "\n"
19971 " Redacted form: plscmap1n(ncol1)\n"
19972 "\n"
19973 " This function is used in examples 8, 11, 20, and 21.\n"
19974 "\n"
19975 "\n"
19976 "\n"
19977 "SYNOPSIS:\n"
19978 "\n"
19979 "plscmap1n(ncol1)\n"
19980 "\n"
19981 "ARGUMENTS:\n"
19982 "\n"
19983 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19984 " the cmap1 palette. If this number is zero or less, then the value\n"
19985 " from the previous call to plscmap1n is used and if there is no\n"
19986 " previous call, then a default value is used.\n"
19987 "\n"
19988 ""},
19989 { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, "\n"
19990 "Set the cmap1 argument range for continuous color plots\n"
19991 "\n"
19992 "DESCRIPTION:\n"
19993 "\n"
19994 " Set the cmap1 argument range for continuous color plots that\n"
19995 " corresponds to the range of data values. The maximum range\n"
19996 " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
19997 " the cmap1 argument range that is specified with this routine, the\n"
19998 " smaller the subset of the cmap1 color palette that is used to\n"
19999 " represent the continuous data being plotted. If\n"
20000 " min_color is greater than\n"
20001 " max_color or\n"
20002 " max_color is greater than 1.0 or\n"
20003 " min_color is less than 0.0 then no change is made to the cmap1\n"
20004 " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
20005 "\n"
20006 " Redacted form: plscmap1_range(min_color, max_color)\n"
20007 "\n"
20008 " This function is currently used in example 33.\n"
20009 "\n"
20010 "\n"
20011 "\n"
20012 "SYNOPSIS:\n"
20013 "\n"
20014 "plscmap1_range(min_color, max_color)\n"
20015 "\n"
20016 "ARGUMENTS:\n"
20017 "\n"
20018 " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
20019 " than 0.0, then 0.0 is used instead.\n"
20020 "\n"
20021 " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
20022 " than 1.0, then 1.0 is used instead.\n"
20023 "\n"
20024 ""},
20025 { "plgcmap1_range", _wrap_plgcmap1_range, METH_NOARGS, "\n"
20026 "Get the cmap1 argument range for continuous color plots\n"
20027 "\n"
20028 "DESCRIPTION:\n"
20029 "\n"
20030 " Get the cmap1 argument range for continuous color plots. (Use\n"
20031 " plscmap1_range to set the cmap1 argument range.)\n"
20032 "\n"
20033 " Redacted form: plgcmap1_range(min_color, max_color)\n"
20034 "\n"
20035 " This function is currently not used in any example.\n"
20036 "\n"
20037 "\n"
20038 "\n"
20039 "SYNOPSIS:\n"
20040 "\n"
20041 "plgcmap1_range(min_color, max_color)\n"
20042 "\n"
20043 "ARGUMENTS:\n"
20044 "\n"
20045 " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20046 " minimum cmap1 argument.\n"
20047 "\n"
20048 " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20049 " maximum cmap1 argument.\n"
20050 "\n"
20051 ""},
20052 { "plscol0", _wrap_plscol0, METH_VARARGS, "\n"
20053 "Set 8-bit RGB values for given cmap0 color index\n"
20054 "\n"
20055 "DESCRIPTION:\n"
20056 "\n"
20057 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
20058 " index. Overwrites the previous color value for the given index and,\n"
20059 " thus, does not result in any additional allocation of space for\n"
20060 " colors.\n"
20061 "\n"
20062 " Redacted form: plscol0(icol0, r, g, b)\n"
20063 "\n"
20064 " This function is used in any example 31.\n"
20065 "\n"
20066 "\n"
20067 "\n"
20068 "SYNOPSIS:\n"
20069 "\n"
20070 "plscol0(icol0, r, g, b)\n"
20071 "\n"
20072 "ARGUMENTS:\n"
20073 "\n"
20074 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20075 " number of colors (which is set by default, by plscmap0n, or even\n"
20076 " by plscmap0).\n"
20077 "\n"
20078 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20079 " degree of red in the color.\n"
20080 "\n"
20081 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20082 " degree of green in the color.\n"
20083 "\n"
20084 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20085 " degree of blue in the color.\n"
20086 "\n"
20087 ""},
20088 { "plscol0a", _wrap_plscol0a, METH_VARARGS, "\n"
20089 "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
20090 "\n"
20091 "DESCRIPTION:\n"
20092 "\n"
20093 " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
20094 " (see the PLplot documentation) index. Overwrites the previous color\n"
20095 " value for the given index and, thus, does not result in any additional\n"
20096 " allocation of space for colors.\n"
20097 "\n"
20098 " This function is used in example 30.\n"
20099 "\n"
20100 "\n"
20101 "\n"
20102 "SYNOPSIS:\n"
20103 "\n"
20104 "plscol0a(icol0, r, g, b, alpha)\n"
20105 "\n"
20106 "ARGUMENTS:\n"
20107 "\n"
20108 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20109 " number of colors (which is set by default, by plscmap0n, or even\n"
20110 " by plscmap0).\n"
20111 "\n"
20112 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20113 " degree of red in the color.\n"
20114 "\n"
20115 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20116 " degree of green in the color.\n"
20117 "\n"
20118 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20119 " degree of blue in the color.\n"
20120 "\n"
20121 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20122 " (0.0-1.0).\n"
20123 "\n"
20124 ""},
20125 { "plscolbg", _wrap_plscolbg, METH_VARARGS, "\n"
20126 "Set the background color by 8-bit RGB value\n"
20127 "\n"
20128 "DESCRIPTION:\n"
20129 "\n"
20130 " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
20131 " the PLplot documentation).\n"
20132 "\n"
20133 " Redacted form: plscolbg(r, g, b)\n"
20134 "\n"
20135 " This function is used in examples 15 and 31.\n"
20136 "\n"
20137 "\n"
20138 "\n"
20139 "SYNOPSIS:\n"
20140 "\n"
20141 "plscolbg(r, g, b)\n"
20142 "\n"
20143 "ARGUMENTS:\n"
20144 "\n"
20145 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20146 " degree of red in the color.\n"
20147 "\n"
20148 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20149 " degree of green in the color.\n"
20150 "\n"
20151 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20152 " degree of blue in the color.\n"
20153 "\n"
20154 ""},
20155 { "plscolbga", _wrap_plscolbga, METH_VARARGS, "\n"
20156 "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
20157 "\n"
20158 "DESCRIPTION:\n"
20159 "\n"
20160 " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
20161 " PLFLT alpha transparency value (see the PLplot documentation).\n"
20162 "\n"
20163 " This function is used in example 31.\n"
20164 "\n"
20165 "\n"
20166 "\n"
20167 "SYNOPSIS:\n"
20168 "\n"
20169 "plscolbga(r, g, b, alpha)\n"
20170 "\n"
20171 "ARGUMENTS:\n"
20172 "\n"
20173 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20174 " degree of red in the color.\n"
20175 "\n"
20176 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20177 " degree of green in the color.\n"
20178 "\n"
20179 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20180 " degree of blue in the color.\n"
20181 "\n"
20182 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20183 " (0.0-1.0).\n"
20184 "\n"
20185 ""},
20186 { "plscolor", _wrap_plscolor, METH_O, "\n"
20187 "Used to globally turn color output on/off\n"
20188 "\n"
20189 "DESCRIPTION:\n"
20190 "\n"
20191 " Used to globally turn color output on/off for those drivers/devices\n"
20192 " that support it.\n"
20193 "\n"
20194 " Redacted form: plscolor(color)\n"
20195 "\n"
20196 " This function is used in example 31.\n"
20197 "\n"
20198 "\n"
20199 "\n"
20200 "SYNOPSIS:\n"
20201 "\n"
20202 "plscolor(color)\n"
20203 "\n"
20204 "ARGUMENTS:\n"
20205 "\n"
20206 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
20207 " turned off. If non-zero, color is turned on.\n"
20208 "\n"
20209 ""},
20210 { "plscompression", _wrap_plscompression, METH_O, "\n"
20211 "Set device-compression level\n"
20212 "\n"
20213 "DESCRIPTION:\n"
20214 "\n"
20215 " Set device-compression level. Only used for drivers that provide\n"
20216 " compression. This function, if used, should be invoked before a call\n"
20217 " to plinit.\n"
20218 "\n"
20219 " Redacted form: plscompression(compression)\n"
20220 "\n"
20221 " This function is used in example 31.\n"
20222 "\n"
20223 "\n"
20224 "\n"
20225 "SYNOPSIS:\n"
20226 "\n"
20227 "plscompression(compression)\n"
20228 "\n"
20229 "ARGUMENTS:\n"
20230 "\n"
20231 " compression (PLINT, input) : The desired compression level. This is\n"
20232 " a device-dependent value. Currently only the jpeg and png devices\n"
20233 " use these values. For jpeg value is the jpeg quality which should\n"
20234 " normally be in the range 0-95. Higher values denote higher quality\n"
20235 " and hence larger image sizes. For png values are in the range -1\n"
20236 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
20237 " A value of -1 denotes the default zlib compression level. Values\n"
20238 " in the range 10-99 are divided by 10 and then used as the zlib\n"
20239 " compression level. Higher compression levels correspond to greater\n"
20240 " compression and small file sizes at the expense of more\n"
20241 " computation.\n"
20242 "\n"
20243 ""},
20244 { "plsdev", _wrap_plsdev, METH_O, "\n"
20245 "Set the device (keyword) name\n"
20246 "\n"
20247 "DESCRIPTION:\n"
20248 "\n"
20249 " Set the device (keyword) name.\n"
20250 "\n"
20251 " Redacted form: plsdev(devname)\n"
20252 "\n"
20253 " This function is used in examples 1, 14, and 20.\n"
20254 "\n"
20255 "\n"
20256 "\n"
20257 "SYNOPSIS:\n"
20258 "\n"
20259 "plsdev(devname)\n"
20260 "\n"
20261 "ARGUMENTS:\n"
20262 "\n"
20263 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20264 " containing the device name keyword of the required output device.\n"
20265 " If\n"
20266 " devname is NULL or if the first character of the string is a ``?'',\n"
20267 " the normal (prompted) start up is used.\n"
20268 "\n"
20269 ""},
20270 { "plsdidev", _wrap_plsdidev, METH_VARARGS, "\n"
20271 "Set parameters that define current device-space window\n"
20272 "\n"
20273 "DESCRIPTION:\n"
20274 "\n"
20275 " Set relative margin width, aspect ratio, and relative justification\n"
20276 " that define current device-space window. If you want to just use the\n"
20277 " previous value for any of these, just pass in the magic value\n"
20278 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
20279 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
20280 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
20281 " to a device-specific value.\n"
20282 "\n"
20283 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20284 "\n"
20285 " This function is used in example 31.\n"
20286 "\n"
20287 "\n"
20288 "\n"
20289 "SYNOPSIS:\n"
20290 "\n"
20291 "plsdidev(mar, aspect, jx, jy)\n"
20292 "\n"
20293 "ARGUMENTS:\n"
20294 "\n"
20295 " mar (PLFLT, input) : Relative margin width.\n"
20296 "\n"
20297 " aspect (PLFLT, input) : Aspect ratio.\n"
20298 "\n"
20299 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20300 " the range -0.5 to 0.5.\n"
20301 "\n"
20302 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20303 " the range -0.5 to 0.5.\n"
20304 "\n"
20305 ""},
20306 { "plsdimap", _wrap_plsdimap, METH_VARARGS, "\n"
20307 "Set up transformation from metafile coordinates\n"
20308 "\n"
20309 "DESCRIPTION:\n"
20310 "\n"
20311 " Set up transformation from metafile coordinates. The size of the plot\n"
20312 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20313 " general-purpose facility just yet (not sure why the user would need\n"
20314 " it, for one).\n"
20315 "\n"
20316 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20317 " dimypmm)\n"
20318 "\n"
20319 " This function is not used in any examples.\n"
20320 "\n"
20321 "\n"
20322 "\n"
20323 "SYNOPSIS:\n"
20324 "\n"
20325 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20326 "\n"
20327 "ARGUMENTS:\n"
20328 "\n"
20329 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
20330 "\n"
20331 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
20332 "\n"
20333 " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
20334 "\n"
20335 " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
20336 "\n"
20337 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20338 "\n"
20339 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20340 "\n"
20341 ""},
20342 { "plsdiori", _wrap_plsdiori, METH_O, "\n"
20343 "Set plot orientation\n"
20344 "\n"
20345 "DESCRIPTION:\n"
20346 "\n"
20347 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20348 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20349 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20350 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20351 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20352 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20353 " not called the default value of rot is 0.\n"
20354 "\n"
20355 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20356 " probably want to change the aspect ratio to a value suitable for the\n"
20357 " plot orientation using a call to plsdidev or the command-line options\n"
20358 " -a or -freeaspect. For more documentation of those options see the\n"
20359 " PLplot documentation. Such command-line options can be set internally\n"
20360 " using plsetopt or set directly using the command line and parsed using\n"
20361 " a call to plparseopts.\n"
20362 "\n"
20363 " Redacted form: plsdiori(rot)\n"
20364 "\n"
20365 " This function is not used in any examples.\n"
20366 "\n"
20367 "\n"
20368 "\n"
20369 "SYNOPSIS:\n"
20370 "\n"
20371 "plsdiori(rot)\n"
20372 "\n"
20373 "ARGUMENTS:\n"
20374 "\n"
20375 " rot (PLFLT, input) : Plot orientation parameter.\n"
20376 "\n"
20377 ""},
20378 { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, "\n"
20379 "Set parameters that define current plot-space window\n"
20380 "\n"
20381 "DESCRIPTION:\n"
20382 "\n"
20383 " Set relative minima and maxima that define the current plot-space\n"
20384 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20385 " xmax, and ymax are 0., 0., 1., and 1.\n"
20386 "\n"
20387 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20388 "\n"
20389 " This function is used in example 31.\n"
20390 "\n"
20391 "\n"
20392 "\n"
20393 "SYNOPSIS:\n"
20394 "\n"
20395 "plsdiplt(xmin, ymin, xmax, ymax)\n"
20396 "\n"
20397 "ARGUMENTS:\n"
20398 "\n"
20399 " xmin (PLFLT, input) : Relative minimum in x.\n"
20400 "\n"
20401 " ymin (PLFLT, input) : Relative minimum in y.\n"
20402 "\n"
20403 " xmax (PLFLT, input) : Relative maximum in x.\n"
20404 "\n"
20405 " ymax (PLFLT, input) : Relative maximum in y.\n"
20406 "\n"
20407 ""},
20408 { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, "\n"
20409 "Set parameters incrementally (zoom mode) that define current plot-space window\n"
20410 "\n"
20411 "DESCRIPTION:\n"
20412 "\n"
20413 " Set relative minima and maxima incrementally (zoom mode) that define\n"
20414 " the current plot-space window. This function has the same effect as\n"
20415 " plsdiplt if that function has not been previously called. Otherwise,\n"
20416 " this function implements zoom mode using the transformation min_used =\n"
20417 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20418 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20419 " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20420 "\n"
20421 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20422 "\n"
20423 " This function is used in example 31.\n"
20424 "\n"
20425 "\n"
20426 "\n"
20427 "SYNOPSIS:\n"
20428 "\n"
20429 "plsdiplz(xmin, ymin, xmax, ymax)\n"
20430 "\n"
20431 "ARGUMENTS:\n"
20432 "\n"
20433 " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20434 "\n"
20435 " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20436 "\n"
20437 " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20438 "\n"
20439 " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20440 "\n"
20441 ""},
20442 { "plseed", _wrap_plseed, METH_O, "\n"
20443 "Set seed for internal random number generator.\n"
20444 "\n"
20445 "DESCRIPTION:\n"
20446 "\n"
20447 " Set the seed for the internal random number generator. See plrandd for\n"
20448 " further details.\n"
20449 "\n"
20450 " Redacted form: plseed(seed)\n"
20451 "\n"
20452 " This function is used in example 21.\n"
20453 "\n"
20454 "\n"
20455 "\n"
20456 "SYNOPSIS:\n"
20457 "\n"
20458 "plseed(seed)\n"
20459 "\n"
20460 "ARGUMENTS:\n"
20461 "\n"
20462 " seed (unsigned int, input) : Seed for random number generator.\n"
20463 "\n"
20464 ""},
20465 { "plsesc", _wrap_plsesc, METH_O, "\n"
20466 "Set the escape character for text strings\n"
20467 "\n"
20468 "DESCRIPTION:\n"
20469 "\n"
20470 " Set the escape character for text strings. From C (in contrast to\n"
20471 " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
20472 " characters are allowed to prevent the user from shooting himself in\n"
20473 " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
20474 " use of backslash as a character escape). Here are the allowed escape\n"
20475 " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
20476 " #, ASCII 35\n"
20477 " $, ASCII 36\n"
20478 " %, ASCII 37\n"
20479 " &, ASCII 38\n"
20480 " *, ASCII 42\n"
20481 " @, ASCII 64\n"
20482 " ^, ASCII 94\n"
20483 " ~, ASCII 126\n"
20484 "\n"
20485 "\n"
20486 " Redacted form: General: plsesc(esc)\n"
20487 "\n"
20488 "\n"
20489 " This function is used in example 29.\n"
20490 "\n"
20491 "\n"
20492 "\n"
20493 "SYNOPSIS:\n"
20494 "\n"
20495 "plsesc(esc)\n"
20496 "\n"
20497 "ARGUMENTS:\n"
20498 "\n"
20499 " esc (char, input) : Escape character.\n"
20500 "\n"
20501 ""},
20502 { "plsetopt", _wrap_plsetopt, METH_VARARGS, "\n"
20503 "Set any command-line option\n"
20504 "\n"
20505 "DESCRIPTION:\n"
20506 "\n"
20507 " Set any command-line option internally from a program before it\n"
20508 " invokes plinit. opt is the name of the command-line option and optarg\n"
20509 " is the corresponding command-line option argument.\n"
20510 "\n"
20511 " This function returns 0 on success.\n"
20512 "\n"
20513 " Redacted form: plsetopt(opt, optarg)\n"
20514 "\n"
20515 " This function is used in example 14.\n"
20516 "\n"
20517 "\n"
20518 "\n"
20519 "SYNOPSIS:\n"
20520 "\n"
20521 "PLINT plsetopt(opt, optarg)\n"
20522 "\n"
20523 "ARGUMENTS:\n"
20524 "\n"
20525 " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20526 " the command-line option.\n"
20527 "\n"
20528 " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20529 " containing the argument of the command-line option.\n"
20530 "\n"
20531 ""},
20532 { "plsfam", _wrap_plsfam, METH_VARARGS, "\n"
20533 "Set family file parameters\n"
20534 "\n"
20535 "DESCRIPTION:\n"
20536 "\n"
20537 " Sets variables dealing with output file familying. Does nothing if\n"
20538 " familying not supported by the driver. This routine, if used, must be\n"
20539 " called before initializing PLplot. See the PLplot documentation for\n"
20540 " more information.\n"
20541 "\n"
20542 " Redacted form: plsfam(fam, num, bmax)\n"
20543 "\n"
20544 " This function is used in examples 14 and 31.\n"
20545 "\n"
20546 "\n"
20547 "\n"
20548 "SYNOPSIS:\n"
20549 "\n"
20550 "plsfam(fam, num, bmax)\n"
20551 "\n"
20552 "ARGUMENTS:\n"
20553 "\n"
20554 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20555 " is enabled.\n"
20556 "\n"
20557 " num (PLINT, input) : Current family file number.\n"
20558 "\n"
20559 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20560 " file.\n"
20561 "\n"
20562 ""},
20563 { "plsfci", _wrap_plsfci, METH_O, "\n"
20564 "Set FCI (font characterization integer)\n"
20565 "\n"
20566 "DESCRIPTION:\n"
20567 "\n"
20568 " Sets font characteristics to be used at the start of the next string\n"
20569 " using the FCI approach. See the PLplot documentation for more\n"
20570 " information. Note, plsfont (which calls plsfci internally) provides a\n"
20571 " more user-friendly API for setting the font characterisitics.\n"
20572 "\n"
20573 " Redacted form: General: plsfci(fci)\n"
20574 "\n"
20575 "\n"
20576 " This function is used in example 23.\n"
20577 "\n"
20578 "\n"
20579 "\n"
20580 "SYNOPSIS:\n"
20581 "\n"
20582 "plsfci(fci)\n"
20583 "\n"
20584 "ARGUMENTS:\n"
20585 "\n"
20586 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20587 " of FCI.\n"
20588 "\n"
20589 ""},
20590 { "plsfnam", _wrap_plsfnam, METH_O, "\n"
20591 "Set output file name\n"
20592 "\n"
20593 "DESCRIPTION:\n"
20594 "\n"
20595 " Sets the current output file name, if applicable. If the file name\n"
20596 " has not been specified and is required by the driver, the user will be\n"
20597 " prompted for it. If using the X-windows output driver, this sets the\n"
20598 " display name. This routine, if used, must be called before\n"
20599 " initializing PLplot.\n"
20600 "\n"
20601 " Redacted form: plsfnam(fnam)\n"
20602 "\n"
20603 " This function is used in examples 1 and 20.\n"
20604 "\n"
20605 "\n"
20606 "\n"
20607 "SYNOPSIS:\n"
20608 "\n"
20609 "plsfnam(fnam)\n"
20610 "\n"
20611 "ARGUMENTS:\n"
20612 "\n"
20613 " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20614 " the file name.\n"
20615 "\n"
20616 ""},
20617 { "plsfont", _wrap_plsfont, METH_VARARGS, "\n"
20618 "Set family, style and weight of the current font\n"
20619 "\n"
20620 "DESCRIPTION:\n"
20621 "\n"
20622 " Sets the current font. See the PLplot documentation for more\n"
20623 " information on font selection.\n"
20624 "\n"
20625 " Redacted form: plsfont(family, style, weight)\n"
20626 "\n"
20627 " This function is used in example 23.\n"
20628 "\n"
20629 "\n"
20630 "\n"
20631 "SYNOPSIS:\n"
20632 "\n"
20633 "plsfont(family, style, weight)\n"
20634 "\n"
20635 "ARGUMENTS:\n"
20636 "\n"
20637 " family (PLINT, input) : Font family to select for the current font.\n"
20638 " The available values are given by the PL_FCI_* constants in\n"
20639 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20640 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20641 " signifies that the font family should not be altered.\n"
20642 "\n"
20643 " style (PLINT, input) : Font style to select for the current font.\n"
20644 " The available values are given by the PL_FCI_* constants in\n"
20645 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20646 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20647 " should not be altered.\n"
20648 "\n"
20649 " weight (PLINT, input) : Font weight to select for the current font.\n"
20650 " The available values are given by the PL_FCI_* constants in\n"
20651 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20652 " negative value signifies that the font weight should not be\n"
20653 " altered.\n"
20654 "\n"
20655 ""},
20656 { "plshades", _wrap_plshades, METH_VARARGS, "\n"
20657 "Shade regions on the basis of value\n"
20658 "\n"
20659 "DESCRIPTION:\n"
20660 "\n"
20661 " Shade regions on the basis of value. This is the high-level routine\n"
20662 " for making continuous color shaded plots with cmap1 while plshade\n"
20663 " should be used to plot individual shaded regions using either cmap0 or\n"
20664 " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20665 " our supported languages.\n"
20666 "\n"
20667 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20668 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20669 " pltr_data)\n"
20670 "\n"
20671 "\n"
20672 " This function is used in examples 16, 21, and 22.\n"
20673 "\n"
20674 "\n"
20675 "\n"
20676 "SYNOPSIS:\n"
20677 "\n"
20678 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20679 "\n"
20680 "ARGUMENTS:\n"
20681 "\n"
20682 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20683 " plot. Should have dimensions of\n"
20684 " nx by\n"
20685 " ny.\n"
20686 "\n"
20687 " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20688 "\n"
20689 " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20690 "\n"
20691 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20692 " the region that should be plotted in the shade plot. This\n"
20693 " function accepts x and y coordinates as input arguments and must\n"
20694 " return 1 if the point is to be included in the shade plot and 0\n"
20695 " otherwise. If you want to plot the entire shade plot (the usual\n"
20696 " case), this argument should be set to NULL.\n"
20697 "\n"
20698 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20699 " pltr below for how these arguments are used (only for the special case\n"
20700 " when the callback function\n"
20701 " pltr is not supplied).\n"
20702 "\n"
20703 " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20704 " corresponding to the edges of each shaded region that will be\n"
20705 " plotted by this function. To work properly the levels should be\n"
20706 " monotonic.\n"
20707 "\n"
20708 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20709 " of shade edge values in clevel).\n"
20710 "\n"
20711 " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20712 " pattern.\n"
20713 "\n"
20714 " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20715 " contours defining edges of shaded regions. The pen color is only\n"
20716 " temporary set for the contour drawing. Set this value to zero or\n"
20717 " less if no shade edge contours are wanted.\n"
20718 "\n"
20719 " cont_width (PLFLT, input) : Defines line width used for contours\n"
20720 " defining edges of shaded regions. This value may not be honored\n"
20721 " by all drivers. The pen width is only temporary set for the\n"
20722 " contour drawing. Set this value to zero or less if no shade edge\n"
20723 " contours are wanted.\n"
20724 "\n"
20725 " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20726 " region. Use plfill for this purpose.\n"
20727 "\n"
20728 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20729 " map to rectangles after coordinate transformation with pltrl.\n"
20730 " Otherwise, set rectangular to false. If rectangular is set to\n"
20731 " true, plshade tries to save time by filling large rectangles.\n"
20732 " This optimization fails if the coordinate transformation distorts\n"
20733 " the shape of rectangles. For example a plot in polar coordinates\n"
20734 " has to have rectangular set to false.\n"
20735 "\n"
20736 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20737 " defines the transformation between the zero-based indices of the\n"
20738 " matrix a and world coordinates. If\n"
20739 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20740 " indices of a are mapped to the range\n"
20741 " xmin through\n"
20742 " xmax and the y indices of a are mapped to the range\n"
20743 " ymin through\n"
20744 " ymax.For the C case, transformation functions are provided in the\n"
20745 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20746 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20747 " matrices. In addition, C callback routines for the transformation\n"
20748 " can be supplied by the user such as the mypltr function in\n"
20749 " examples/c/x09c.c which provides a general linear transformation\n"
20750 " between index coordinates and world coordinates.For languages\n"
20751 " other than C you should consult the PLplot documentation for the\n"
20752 " details concerning how PLTRANSFORM_callback arguments are\n"
20753 " interfaced. However, in general, a particular pattern of\n"
20754 " callback-associated arguments such as a tr vector with 6 elements;\n"
20755 " xg and yg vectors; or xg and yg matrices are respectively\n"
20756 " interfaced to a linear-transformation routine similar to the above\n"
20757 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20758 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20759 " support native language callbacks for handling index to\n"
20760 " world-coordinate transformations. Examples of these various\n"
20761 " approaches are given in examples/<language>x09*,\n"
20762 " examples/<language>x16*, examples/<language>x20*,\n"
20763 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20764 " supported languages.\n"
20765 "\n"
20766 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20767 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20768 " externally supplied.\n"
20769 "\n"
20770 ""},
20771 { "plshade", _wrap_plshade, METH_VARARGS, "\n"
20772 "Shade individual region on the basis of value\n"
20773 "\n"
20774 "DESCRIPTION:\n"
20775 "\n"
20776 " Shade individual region on the basis of value. Use plshades if you\n"
20777 " want to shade a number of contiguous regions using continuous colors.\n"
20778 " In particular the edge contours are treated properly in plshades. If\n"
20779 " you attempt to do contiguous regions with plshade the contours at the\n"
20780 " edge of the shade are partially obliterated by subsequent plots of\n"
20781 " contiguous shaded regions.\n"
20782 "\n"
20783 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20784 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20785 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20786 "\n"
20787 "\n"
20788 " This function is used in example 15.\n"
20789 "\n"
20790 "\n"
20791 "\n"
20792 "SYNOPSIS:\n"
20793 "\n"
20794 "plshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20795 "\n"
20796 "ARGUMENTS:\n"
20797 "\n"
20798 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20799 " plot. Should have dimensions of\n"
20800 " nx by\n"
20801 " ny.\n"
20802 "\n"
20803 " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20804 "\n"
20805 " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20806 "\n"
20807 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20808 " the region that should be plotted in the shade plot. This\n"
20809 " function accepts x and y coordinates as input arguments and must\n"
20810 " return 1 if the point is to be included in the shade plot and 0\n"
20811 " otherwise. If you want to plot the entire shade plot (the usual\n"
20812 " case), this argument should be set to NULL.\n"
20813 "\n"
20814 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20815 " pltr below for how these arguments are used (only for the special case\n"
20816 " when the callback function\n"
20817 " pltr is not supplied).\n"
20818 "\n"
20819 " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20820 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20821 "\n"
20822 " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20823 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20824 "\n"
20825 " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20826 " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20827 " then sh_color is interpreted as a cmap1 argument in the range\n"
20828 " (0.0-1.0).\n"
20829 "\n"
20830 " sh_color (PLFLT, input) : Defines color map index with integer\n"
20831 " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20832 "\n"
20833 " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20834 "\n"
20835 " min_color (PLINT, input) : Defines pen color, width used by the\n"
20836 " boundary of shaded region. The min values are used for the\n"
20837 " shade_min boundary, and the max values are used on the shade_max\n"
20838 " boundary. Set color and width to zero for no plotted boundaries.\n"
20839 "\n"
20840 " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20841 " boundary of shaded region. The min values are used for the\n"
20842 " shade_min boundary, and the max values are used on the shade_max\n"
20843 " boundary. Set color and width to zero for no plotted boundaries.\n"
20844 "\n"
20845 " max_color (PLINT, input) : Defines pen color, width used by the\n"
20846 " boundary of shaded region. The min values are used for the\n"
20847 " shade_min boundary, and the max values are used on the shade_max\n"
20848 " boundary. Set color and width to zero for no plotted boundaries.\n"
20849 "\n"
20850 " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20851 " boundary of shaded region. The min values are used for the\n"
20852 " shade_min boundary, and the max values are used on the shade_max\n"
20853 " boundary. Set color and width to zero for no plotted boundaries.\n"
20854 "\n"
20855 " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20856 " Use plfill. Future version of PLplot may have other fill\n"
20857 " routines.\n"
20858 "\n"
20859 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20860 " map to rectangles after coordinate transformation with pltrl.\n"
20861 " Otherwise, set rectangular to false. If rectangular is set to\n"
20862 " true, plshade tries to save time by filling large rectangles.\n"
20863 " This optimization fails if the coordinate transformation distorts\n"
20864 " the shape of rectangles. For example a plot in polar coordinates\n"
20865 " has to have rectangular set to false.\n"
20866 "\n"
20867 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20868 " defines the transformation between the zero-based indices of the\n"
20869 " matrix a and world coordinates. If\n"
20870 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20871 " indices of a are mapped to the range\n"
20872 " xmin through\n"
20873 " xmax and the y indices of a are mapped to the range\n"
20874 " ymin through\n"
20875 " ymax.For the C case, transformation functions are provided in the\n"
20876 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20877 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20878 " matrices. In addition, C callback routines for the transformation\n"
20879 " can be supplied by the user such as the mypltr function in\n"
20880 " examples/c/x09c.c which provides a general linear transformation\n"
20881 " between index coordinates and world coordinates.For languages\n"
20882 " other than C you should consult the PLplot documentation for the\n"
20883 " details concerning how PLTRANSFORM_callback arguments are\n"
20884 " interfaced. However, in general, a particular pattern of\n"
20885 " callback-associated arguments such as a tr vector with 6 elements;\n"
20886 " xg and yg vectors; or xg and yg matrices are respectively\n"
20887 " interfaced to a linear-transformation routine similar to the above\n"
20888 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20889 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20890 " support native language callbacks for handling index to\n"
20891 " world-coordinate transformations. Examples of these various\n"
20892 " approaches are given in examples/<language>x09*,\n"
20893 " examples/<language>x16*, examples/<language>x20*,\n"
20894 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20895 " supported languages.\n"
20896 "\n"
20897 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20898 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20899 " externally supplied.\n"
20900 "\n"
20901 ""},
20902 { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, "\n"
20903 "Assign a function to use for generating custom axis labels\n"
20904 "\n"
20905 "DESCRIPTION:\n"
20906 "\n"
20907 " This function allows a user to provide their own function to provide\n"
20908 " axis label text. The user function is given the numeric value for a\n"
20909 " point on an axis and returns a string label to correspond with that\n"
20910 " value. Custom axis labels can be enabled by passing appropriate\n"
20911 " arguments to plenv, plbox, plbox3 and similar functions.\n"
20912 "\n"
20913 " This function is used in example 19.\n"
20914 "\n"
20915 "\n"
20916 "\n"
20917 "SYNOPSIS:\n"
20918 "\n"
20919 "plslabelfunc(label_func, label_data)\n"
20920 "\n"
20921 "ARGUMENTS:\n"
20922 "\n"
20923 " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20924 " label function. In order to reset to the default labelling, set\n"
20925 " this to NULL. The labelling function parameters are, in order:\n"
20926 " axis: This indicates which axis a label is being requested for.\n"
20927 " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20928 "\n"
20929 " value: This is the value along the axis which is being labelled.\n"
20930 "\n"
20931 " label_text: The string representation of the label value.\n"
20932 "\n"
20933 " length: The maximum length in characters allowed for label_text.\n"
20934 "\n"
20935 "\n"
20936 " label_data (PLPointer, input) : This parameter may be used to pass\n"
20937 " data to the label_func function.\n"
20938 "\n"
20939 ""},
20940 { "plsmaj", _wrap_plsmaj, METH_VARARGS, "\n"
20941 "Set length of major ticks\n"
20942 "\n"
20943 "DESCRIPTION:\n"
20944 "\n"
20945 " This sets up the length of the major ticks. The actual length is the\n"
20946 " product of the default length and a scaling factor as for character\n"
20947 " height.\n"
20948 "\n"
20949 " Redacted form: plsmaj(def, scale)\n"
20950 "\n"
20951 " This function is used in example 29.\n"
20952 "\n"
20953 "\n"
20954 "\n"
20955 "SYNOPSIS:\n"
20956 "\n"
20957 "plsmaj(def, scale)\n"
20958 "\n"
20959 "ARGUMENTS:\n"
20960 "\n"
20961 " def (PLFLT, input) : The default length of a major tick in\n"
20962 " millimeters, should be set to zero if the default length is to\n"
20963 " remain unchanged.\n"
20964 "\n"
20965 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20966 " actual tick length.\n"
20967 "\n"
20968 ""},
20969 { "plsmem", _wrap_plsmem, METH_VARARGS, "\n"
20970 "Set the memory area to be plotted (RGB)\n"
20971 "\n"
20972 "DESCRIPTION:\n"
20973 "\n"
20974 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20975 " the dev member of the stream structure. Also set the number of pixels\n"
20976 " in the memory passed in\n"
20977 " plotmem, which is a block of memory\n"
20978 " maxy by\n"
20979 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
20980 "\n"
20981 " This memory will have to be freed by the user!\n"
20982 "\n"
20983 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20984 "\n"
20985 " This function is not used in any examples.\n"
20986 "\n"
20987 "\n"
20988 "\n"
20989 "SYNOPSIS:\n"
20990 "\n"
20991 "plsmem(maxx, maxy, plotmem)\n"
20992 "\n"
20993 "ARGUMENTS:\n"
20994 "\n"
20995 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20996 "\n"
20997 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20998 "\n"
20999 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21000 " user-supplied writeable memory area.\n"
21001 "\n"
21002 ""},
21003 { "plsmema", _wrap_plsmema, METH_VARARGS, "\n"
21004 "Set the memory area to be plotted (RGBA)\n"
21005 "\n"
21006 "DESCRIPTION:\n"
21007 "\n"
21008 " Set the memory area to be plotted (with the memcairo driver) as the\n"
21009 " dev member of the stream structure. Also set the number of pixels in\n"
21010 " the memory passed in\n"
21011 " plotmem, which is a block of memory\n"
21012 " maxy by\n"
21013 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
21014 "\n"
21015 " This memory will have to be freed by the user!\n"
21016 "\n"
21017 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
21018 "\n"
21019 " This function is not used in any examples.\n"
21020 "\n"
21021 "\n"
21022 "\n"
21023 "SYNOPSIS:\n"
21024 "\n"
21025 "plsmema(maxx, maxy, plotmem)\n"
21026 "\n"
21027 "ARGUMENTS:\n"
21028 "\n"
21029 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21030 "\n"
21031 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21032 "\n"
21033 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21034 " user-supplied writeable memory area.\n"
21035 "\n"
21036 ""},
21037 { "plsmin", _wrap_plsmin, METH_VARARGS, "\n"
21038 "Set length of minor ticks\n"
21039 "\n"
21040 "DESCRIPTION:\n"
21041 "\n"
21042 " This sets up the length of the minor ticks and the length of the\n"
21043 " terminals on error bars. The actual length is the product of the\n"
21044 " default length and a scaling factor as for character height.\n"
21045 "\n"
21046 " Redacted form: plsmin(def, scale)\n"
21047 "\n"
21048 " This function is used in example 29.\n"
21049 "\n"
21050 "\n"
21051 "\n"
21052 "SYNOPSIS:\n"
21053 "\n"
21054 "plsmin(def, scale)\n"
21055 "\n"
21056 "ARGUMENTS:\n"
21057 "\n"
21058 " def (PLFLT, input) : The default length of a minor tick in\n"
21059 " millimeters, should be set to zero if the default length is to\n"
21060 " remain unchanged.\n"
21061 "\n"
21062 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21063 " actual tick length.\n"
21064 "\n"
21065 ""},
21066 { "plsori", _wrap_plsori, METH_O, "\n"
21067 "Set orientation\n"
21068 "\n"
21069 "DESCRIPTION:\n"
21070 "\n"
21071 " Set integer plot orientation parameter. This function is identical to\n"
21072 " plsdiori except for the type of the argument, and should be used in\n"
21073 " the same way. See the documentation of plsdiori for details.\n"
21074 "\n"
21075 " Redacted form: plsori(ori)\n"
21076 "\n"
21077 " This function is used in example 3.\n"
21078 "\n"
21079 "\n"
21080 "\n"
21081 "SYNOPSIS:\n"
21082 "\n"
21083 "plsori(ori)\n"
21084 "\n"
21085 "ARGUMENTS:\n"
21086 "\n"
21087 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
21088 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
21089 " angle.\n"
21090 "\n"
21091 ""},
21092 { "plspage", _wrap_plspage, METH_VARARGS, "\n"
21093 "Set page parameters\n"
21094 "\n"
21095 "DESCRIPTION:\n"
21096 "\n"
21097 " Sets the page configuration (optional). If an individual parameter is\n"
21098 " zero then that parameter value is not updated. Not all parameters are\n"
21099 " recognized by all drivers and the interpretation is device-dependent.\n"
21100 " The X-window driver uses the length and offset parameters to determine\n"
21101 " the window size and location. The length and offset values are\n"
21102 " expressed in units that are specific to the current driver. For\n"
21103 " instance: screen drivers will usually interpret them as number of\n"
21104 " pixels, whereas printer drivers will usually use mm.\n"
21105 "\n"
21106 " This routine, if used, must be called before initializing PLplot. It\n"
21107 " may be called at later times for interactive drivers to change only\n"
21108 " the dpi for subsequent redraws which you can force via a call to\n"
21109 " plreplot. If this function is not called then the page size defaults\n"
21110 " to landscape A4 for drivers which use real world page sizes and 744\n"
21111 " pixels wide by 538 pixels high for raster drivers. The default value\n"
21112 " for dx and dy is 90 pixels per inch for raster drivers.\n"
21113 "\n"
21114 "\n"
21115 "\n"
21116 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21117 "\n"
21118 " This function is used in examples 14 and 31.\n"
21119 "\n"
21120 "\n"
21121 "\n"
21122 "SYNOPSIS:\n"
21123 "\n"
21124 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21125 "\n"
21126 "ARGUMENTS:\n"
21127 "\n"
21128 " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
21129 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21130 " (e.g. mm).\n"
21131 "\n"
21132 " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
21133 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21134 " (e.g. mm).\n"
21135 "\n"
21136 " xleng (PLINT, input) : Page length, x.\n"
21137 "\n"
21138 " yleng (PLINT, input) : Page length, y.\n"
21139 "\n"
21140 " xoff (PLINT, input) : Page offset, x.\n"
21141 "\n"
21142 " yoff (PLINT, input) : Page offset, y.\n"
21143 "\n"
21144 ""},
21145 { "plspal0", _wrap_plspal0, METH_O, "\n"
21146 "Set the cmap0 palette using the specified cmap0*.pal format file\n"
21147 "\n"
21148 "DESCRIPTION:\n"
21149 "\n"
21150 " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
21151 "\n"
21152 " Redacted form: plspal0(filename)\n"
21153 "\n"
21154 " This function is in example 16.\n"
21155 "\n"
21156 "\n"
21157 "\n"
21158 "SYNOPSIS:\n"
21159 "\n"
21160 "plspal0(filename)\n"
21161 "\n"
21162 "ARGUMENTS:\n"
21163 "\n"
21164 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21165 " containing the name of the cmap0*.pal file. If this string is\n"
21166 " empty, use the default cmap0*.pal file.\n"
21167 "\n"
21168 ""},
21169 { "plspal1", _wrap_plspal1, METH_VARARGS, "\n"
21170 "Set the cmap1 palette using the specified cmap1*.pal format file\n"
21171 "\n"
21172 "DESCRIPTION:\n"
21173 "\n"
21174 " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
21175 "\n"
21176 " Redacted form: plspal1(filename, interpolate)\n"
21177 "\n"
21178 " This function is used in example 16.\n"
21179 "\n"
21180 "\n"
21181 "\n"
21182 "SYNOPSIS:\n"
21183 "\n"
21184 "plspal1(filename, interpolate)\n"
21185 "\n"
21186 "ARGUMENTS:\n"
21187 "\n"
21188 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21189 " containing the name of the cmap1*.pal file. If this string is\n"
21190 " empty, use the default cmap1*.pal file.\n"
21191 "\n"
21192 " interpolate (PLBOOL, input) : If this parameter is true, the\n"
21193 " columns containing the intensity index, r, g, b, alpha and\n"
21194 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
21195 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
21196 " a flag which controls whether the r, g, b data sent to plscmap1la\n"
21197 " are interpreted as HLS or RGB.) If this parameter is false, the\n"
21198 " intensity index and alt_hue_path columns are ignored and the r, g,\n"
21199 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
21200 " are used instead to set the cmap1 palette directly with a call to\n"
21201 " plscmap1a.\n"
21202 "\n"
21203 ""},
21204 { "plspause", _wrap_plspause, METH_O, "\n"
21205 "Set the pause (on end-of-page) status\n"
21206 "\n"
21207 "DESCRIPTION:\n"
21208 "\n"
21209 " Set the pause (on end-of-page) status.\n"
21210 "\n"
21211 " Redacted form: plspause(pause)\n"
21212 "\n"
21213 " This function is in examples 14,20.\n"
21214 "\n"
21215 "\n"
21216 "\n"
21217 "SYNOPSIS:\n"
21218 "\n"
21219 "plspause(pause)\n"
21220 "\n"
21221 "ARGUMENTS:\n"
21222 "\n"
21223 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
21224 " end-of-page for those drivers which support this. Otherwise there\n"
21225 " is no pause.\n"
21226 "\n"
21227 ""},
21228 { "plsstrm", _wrap_plsstrm, METH_O, "\n"
21229 "Set current output stream\n"
21230 "\n"
21231 "DESCRIPTION:\n"
21232 "\n"
21233 " Sets the number of the current output stream. The stream number\n"
21234 " defaults to 0 unless changed by this routine. The first use of this\n"
21235 " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
21236 "\n"
21237 " Redacted form: plsstrm(strm)\n"
21238 "\n"
21239 " This function is examples 1,14,20.\n"
21240 "\n"
21241 "\n"
21242 "\n"
21243 "SYNOPSIS:\n"
21244 "\n"
21245 "plsstrm(strm)\n"
21246 "\n"
21247 "ARGUMENTS:\n"
21248 "\n"
21249 " strm (PLINT, input) : The current stream number.\n"
21250 "\n"
21251 ""},
21252 { "plssub", _wrap_plssub, METH_VARARGS, "\n"
21253 "Set the number of subpages in x and y\n"
21254 "\n"
21255 "DESCRIPTION:\n"
21256 "\n"
21257 " Set the number of subpages in x and y.\n"
21258 "\n"
21259 " Redacted form: plssub(nx, ny)\n"
21260 "\n"
21261 " This function is examples 1,2,14,21,25,27.\n"
21262 "\n"
21263 "\n"
21264 "\n"
21265 "SYNOPSIS:\n"
21266 "\n"
21267 "plssub(nx, ny)\n"
21268 "\n"
21269 "ARGUMENTS:\n"
21270 "\n"
21271 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
21272 " of window columns).\n"
21273 "\n"
21274 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
21275 " of window rows).\n"
21276 "\n"
21277 ""},
21278 { "plssym", _wrap_plssym, METH_VARARGS, "\n"
21279 "Set symbol size\n"
21280 "\n"
21281 "DESCRIPTION:\n"
21282 "\n"
21283 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
21284 " plsym. The actual height of a symbol is the product of the default\n"
21285 " symbol size and a scaling factor as for the character height.\n"
21286 "\n"
21287 " Redacted form: plssym(def, scale)\n"
21288 "\n"
21289 " This function is used in example 29.\n"
21290 "\n"
21291 "\n"
21292 "\n"
21293 "SYNOPSIS:\n"
21294 "\n"
21295 "plssym(def, scale)\n"
21296 "\n"
21297 "ARGUMENTS:\n"
21298 "\n"
21299 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
21300 " should be set to zero if the default height is to remain\n"
21301 " unchanged.\n"
21302 "\n"
21303 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21304 " actual symbol height.\n"
21305 "\n"
21306 ""},
21307 { "plstar", _wrap_plstar, METH_VARARGS, "\n"
21308 "Initialization\n"
21309 "\n"
21310 "DESCRIPTION:\n"
21311 "\n"
21312 " Initializing the plotting package. The program prompts for the device\n"
21313 " keyword or number of the desired output device. Hitting a RETURN in\n"
21314 " response to the prompt is the same as selecting the first device. If\n"
21315 " only one device is enabled when PLplot is installed, plstar will issue\n"
21316 " no prompt. The output device is divided into nx by ny subpages, each\n"
21317 " of which may be used independently. The subroutine pladv is used to\n"
21318 " advance from one subpage to the next.\n"
21319 "\n"
21320 " Redacted form: plstar(nx, ny)\n"
21321 "\n"
21322 " This function is used in example 1.\n"
21323 "\n"
21324 "\n"
21325 "\n"
21326 "SYNOPSIS:\n"
21327 "\n"
21328 "plstar(nx, ny)\n"
21329 "\n"
21330 "ARGUMENTS:\n"
21331 "\n"
21332 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21333 " x direction.\n"
21334 "\n"
21335 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21336 " y direction.\n"
21337 "\n"
21338 ""},
21339 { "plstart", _wrap_plstart, METH_VARARGS, "\n"
21340 "Initialization\n"
21341 "\n"
21342 "DESCRIPTION:\n"
21343 "\n"
21344 " Alternative to plstar for initializing the plotting package. The\n"
21345 " device name keyword for the desired output device must be supplied as\n"
21346 " an argument. These keywords are the same as those printed out by\n"
21347 " plstar. If the requested device is not available, or if the input\n"
21348 " string is empty or begins with ``?'', the prompted start up of plstar\n"
21349 " is used. This routine also divides the output device page into nx by\n"
21350 " ny subpages, each of which may be used independently. The subroutine\n"
21351 " pladv is used to advance from one subpage to the next.\n"
21352 "\n"
21353 " Redacted form: General: plstart(devname, nx, ny)\n"
21354 "\n"
21355 "\n"
21356 " This function is not used in any examples.\n"
21357 "\n"
21358 "\n"
21359 "\n"
21360 "SYNOPSIS:\n"
21361 "\n"
21362 "plstart(devname, nx, ny)\n"
21363 "\n"
21364 "ARGUMENTS:\n"
21365 "\n"
21366 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
21367 " containing the device name keyword of the required output device.\n"
21368 " If\n"
21369 " devname is NULL or if the first character of the string is a ``?'',\n"
21370 " the normal (prompted) start up is used.\n"
21371 "\n"
21372 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21373 " x direction.\n"
21374 "\n"
21375 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21376 " y direction.\n"
21377 "\n"
21378 ""},
21379 { "plstransform", _wrap_plstransform, METH_VARARGS, "\n"
21380 "Set a global coordinate transform function\n"
21381 "\n"
21382 "DESCRIPTION:\n"
21383 "\n"
21384 " This function can be used to define a coordinate transformation which\n"
21385 " affects all elements drawn within the current plot window. The\n"
21386 " coordinate_transform callback function is similar to that provided for\n"
21387 " the plmap and plmeridians functions. The coordinate_transform_data\n"
21388 " parameter may be used to pass extra data to coordinate_transform.\n"
21389 "\n"
21390 " Redacted form: General: plstransform(coordinate_transform,\n"
21391 " coordinate_transform_data)\n"
21392 "\n"
21393 "\n"
21394 " This function is used in examples 19 and 22.\n"
21395 "\n"
21396 "\n"
21397 "\n"
21398 "SYNOPSIS:\n"
21399 "\n"
21400 "plstransform(coordinate_transform, coordinate_transform_data)\n"
21401 "\n"
21402 "ARGUMENTS:\n"
21403 "\n"
21404 " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
21405 " function that defines the transformation from the input (x, y)\n"
21406 " world coordinates to new PLplot world coordinates. If\n"
21407 " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
21408 " case), then no transform is applied.\n"
21409 "\n"
21410 " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
21411 " for\n"
21412 " coordinate_transform.\n"
21413 "\n"
21414 ""},
21415 { "plstring", _wrap_plstring, METH_VARARGS, "\n"
21416 "Plot a glyph at the specified points\n"
21417 "\n"
21418 "DESCRIPTION:\n"
21419 "\n"
21420 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21421 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21422 " is specified with a PLplot user string. Note that the user string is\n"
21423 " not actually limited to one glyph so it is possible (but not normally\n"
21424 " useful) to plot more than one glyph at the specified points with this\n"
21425 " function. As with plmtex and plptex, the user string can contain FCI\n"
21426 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21427 " else PLplot escapes for Hershey or unicode text to determine the\n"
21428 " glyph.\n"
21429 "\n"
21430 " Redacted form: plstring(x, y, string)\n"
21431 "\n"
21432 " This function is used in examples 4, 21 and 26.\n"
21433 "\n"
21434 "\n"
21435 "\n"
21436 "SYNOPSIS:\n"
21437 "\n"
21438 "plstring(n, x, y, string)\n"
21439 "\n"
21440 "ARGUMENTS:\n"
21441 "\n"
21442 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21443 "\n"
21444 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21445 " the points.\n"
21446 "\n"
21447 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21448 " the points.\n"
21449 "\n"
21450 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21451 " the glyph(s) to be plotted at each of the n points.\n"
21452 "\n"
21453 ""},
21454 { "plstring3", _wrap_plstring3, METH_VARARGS, "\n"
21455 "Plot a glyph at the specified 3D points\n"
21456 "\n"
21457 "DESCRIPTION:\n"
21458 "\n"
21459 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21460 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21461 " this function similar to what is done for plline3. The glyph is\n"
21462 " specified with a PLplot user string. Note that the user string is not\n"
21463 " actually limited to one glyph so it is possible (but not normally\n"
21464 " useful) to plot more than one glyph at the specified points with this\n"
21465 " function. As with plmtex and plptex, the user string can contain FCI\n"
21466 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21467 " else PLplot escapes for Hershey or unicode text to determine the\n"
21468 " glyph.\n"
21469 "\n"
21470 " Redacted form: plstring3(x, y, z, string)\n"
21471 "\n"
21472 " This function is used in example 18.\n"
21473 "\n"
21474 "\n"
21475 "\n"
21476 "SYNOPSIS:\n"
21477 "\n"
21478 "plstring3(n, x, y, z, string)\n"
21479 "\n"
21480 "ARGUMENTS:\n"
21481 "\n"
21482 " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21483 "\n"
21484 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21485 " the points.\n"
21486 "\n"
21487 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21488 " the points.\n"
21489 "\n"
21490 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21491 " the points.\n"
21492 "\n"
21493 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21494 " the glyph(s) to be plotted at each of the n points. points.\n"
21495 "\n"
21496 ""},
21497 { "plstripa", _wrap_plstripa, METH_VARARGS, "\n"
21498 "Add a point to a strip chart\n"
21499 "\n"
21500 "DESCRIPTION:\n"
21501 "\n"
21502 " Add a point to a given pen of a given strip chart. There is no need\n"
21503 " for all pens to have the same number of points or to be equally\n"
21504 " sampled in the x coordinate. Allocates memory and rescales as\n"
21505 " necessary.\n"
21506 "\n"
21507 " Redacted form: plstripa(id, pen, x, y)\n"
21508 "\n"
21509 " This function is used in example 17.\n"
21510 "\n"
21511 "\n"
21512 "\n"
21513 "SYNOPSIS:\n"
21514 "\n"
21515 "plstripa(id, pen, x, y)\n"
21516 "\n"
21517 "ARGUMENTS:\n"
21518 "\n"
21519 " id (PLINT, input) : Identification number of the strip chart (set\n"
21520 " up in plstripc).\n"
21521 "\n"
21522 " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21523 "\n"
21524 " x (PLFLT, input) : X coordinate of point to plot.\n"
21525 "\n"
21526 " y (PLFLT, input) : Y coordinate of point to plot.\n"
21527 "\n"
21528 ""},
21529 { "plstripc", _wrap_plstripc, METH_VARARGS, "\n"
21530 "Create a 4-pen strip chart\n"
21531 "\n"
21532 "DESCRIPTION:\n"
21533 "\n"
21534 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21535 "\n"
21536 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21537 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21538 " styline, legline, labx, laby, labz)\n"
21539 "\n"
21540 "\n"
21541 " This function is used in example 17.\n"
21542 "\n"
21543 "\n"
21544 "\n"
21545 "SYNOPSIS:\n"
21546 "\n"
21547 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21548 "\n"
21549 "ARGUMENTS:\n"
21550 "\n"
21551 " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21552 " number of the strip chart to use on plstripa and plstripd.\n"
21553 "\n"
21554 " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21555 " the x-axis specification as in plbox.\n"
21556 "\n"
21557 " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21558 " the y-axis specification as in plbox.\n"
21559 "\n"
21560 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21561 " change as data are added.\n"
21562 "\n"
21563 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21564 " change as data are added.\n"
21565 "\n"
21566 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21567 " is multiplied by the factor (1 +\n"
21568 " xjump) .\n"
21569 "\n"
21570 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21571 " change as data are added.\n"
21572 "\n"
21573 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21574 " change as data are added.\n"
21575 "\n"
21576 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21577 "\n"
21578 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21579 "\n"
21580 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21581 " true, otherwise not.\n"
21582 "\n"
21583 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21584 " otherwise slide display.\n"
21585 "\n"
21586 " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21587 "\n"
21588 " collab (PLINT, input) : Legend color index (cmap0).\n"
21589 "\n"
21590 " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21591 " indices for the 4 pens.\n"
21592 "\n"
21593 " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21594 " indices for the 4 pens.\n"
21595 "\n"
21596 " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21597 " strings containing legends for the 4 pens.\n"
21598 "\n"
21599 " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21600 " the label for the x axis.\n"
21601 "\n"
21602 " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21603 " the label for the y axis.\n"
21604 "\n"
21605 " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21606 " the plot title.\n"
21607 "\n"
21608 ""},
21609 { "plstripd", _wrap_plstripd, METH_O, "\n"
21610 "Deletes and releases memory used by a strip chart\n"
21611 "\n"
21612 "DESCRIPTION:\n"
21613 "\n"
21614 " Deletes and releases memory used by a strip chart.\n"
21615 "\n"
21616 " Redacted form: plstripd(id)\n"
21617 "\n"
21618 " This function is used in example 17.\n"
21619 "\n"
21620 "\n"
21621 "\n"
21622 "SYNOPSIS:\n"
21623 "\n"
21624 "plstripd(id)\n"
21625 "\n"
21626 "ARGUMENTS:\n"
21627 "\n"
21628 " id (PLINT, input) : Identification number of strip chart to delete.\n"
21629 "\n"
21630 ""},
21631 { "plstyl", _wrap_plstyl, METH_VARARGS, "\n"
21632 "Set line style\n"
21633 "\n"
21634 "DESCRIPTION:\n"
21635 "\n"
21636 " This sets up the line style for all lines subsequently drawn. A line\n"
21637 " consists of segments in which the pen is alternately down and up. The\n"
21638 " lengths of these segments are passed in the vectors mark and space\n"
21639 " respectively. The number of mark-space pairs is specified by nms. In\n"
21640 " order to return the line style to the default continuous line, plstyl\n"
21641 " should be called with nms =0 .(see also pllsty)\n"
21642 "\n"
21643 " Redacted form: plstyl(mark, space)\n"
21644 "\n"
21645 " This function is used in examples 1, 9, and 14.\n"
21646 "\n"
21647 "\n"
21648 "\n"
21649 "SYNOPSIS:\n"
21650 "\n"
21651 "plstyl(nms, mark, space)\n"
21652 "\n"
21653 "ARGUMENTS:\n"
21654 "\n"
21655 " nms (PLINT, input) : The number of mark and space elements in a\n"
21656 " line. Thus a simple broken line can be obtained by setting nms=1\n"
21657 " . A continuous line is specified by setting nms=0 .\n"
21658 "\n"
21659 " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21660 " segments during which the pen is down, measured in micrometers.\n"
21661 "\n"
21662 " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21663 " the segments during which the pen is up, measured in micrometers.\n"
21664 "\n"
21665 ""},
21666 { "plsvect", _wrap_plsvect, METH_VARARGS, "\n"
21667 "Set arrow style for vector plots\n"
21668 "\n"
21669 "DESCRIPTION:\n"
21670 "\n"
21671 " Set the style for the arrow used by plvect to plot vectors.\n"
21672 "\n"
21673 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21674 "\n"
21675 " This function is used in example 22.\n"
21676 "\n"
21677 "\n"
21678 "\n"
21679 "SYNOPSIS:\n"
21680 "\n"
21681 "plsvect(arrowx, arrowy, npts, fill)\n"
21682 "\n"
21683 "ARGUMENTS:\n"
21684 "\n"
21685 " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21686 " the x and y points which make up the arrow. The arrow is plotted\n"
21687 " by joining these points to form a polygon. The scaling assumes\n"
21688 " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21689 " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21690 " will be reset to its default.\n"
21691 "\n"
21692 " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21693 " arrowy.\n"
21694 "\n"
21695 " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21696 " fill is false then the arrow is open.\n"
21697 "\n"
21698 ""},
21699 { "plsvpa", _wrap_plsvpa, METH_VARARGS, "\n"
21700 "Specify viewport in absolute coordinates\n"
21701 "\n"
21702 "DESCRIPTION:\n"
21703 "\n"
21704 " Alternate routine to plvpor for setting up the viewport. This routine\n"
21705 " should be used only if the viewport is required to have a definite\n"
21706 " size in millimeters. The routine plgspa is useful for finding out the\n"
21707 " size of the current subpage.\n"
21708 "\n"
21709 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21710 "\n"
21711 " This function is used in example 10.\n"
21712 "\n"
21713 "\n"
21714 "\n"
21715 "SYNOPSIS:\n"
21716 "\n"
21717 "plsvpa(xmin, xmax, ymin, ymax)\n"
21718 "\n"
21719 "ARGUMENTS:\n"
21720 "\n"
21721 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21722 " viewport from the left-hand edge of the subpage in millimeters.\n"
21723 "\n"
21724 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21725 " viewport from the left-hand edge of the subpage in millimeters.\n"
21726 "\n"
21727 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21728 " viewport from the bottom edge of the subpage in millimeters.\n"
21729 "\n"
21730 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21731 " from the bottom edge of the subpage in millimeters.\n"
21732 "\n"
21733 ""},
21734 { "plsxax", _wrap_plsxax, METH_VARARGS, "\n"
21735 "Set x axis parameters\n"
21736 "\n"
21737 "DESCRIPTION:\n"
21738 "\n"
21739 " Sets values of the digmax and digits flags for the x axis. See the\n"
21740 " PLplot documentation for more information.\n"
21741 "\n"
21742 " Redacted form: plsxax(digmax, digits)\n"
21743 "\n"
21744 " This function is used in example 31.\n"
21745 "\n"
21746 "\n"
21747 "\n"
21748 "SYNOPSIS:\n"
21749 "\n"
21750 "plsxax(digmax, digits)\n"
21751 "\n"
21752 "ARGUMENTS:\n"
21753 "\n"
21754 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21755 " digits for the x axis. If nonzero, the printed label will be\n"
21756 " switched to a floating-point representation when the number of\n"
21757 " digits exceeds digmax.\n"
21758 "\n"
21759 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21760 " its value here has no effect since it is set only by plbox or\n"
21761 " plbox3. However, the user may obtain its value after a call to\n"
21762 " either of these functions by calling plgxax.\n"
21763 "\n"
21764 ""},
21765 { "plsyax", _wrap_plsyax, METH_VARARGS, "\n"
21766 "Set y axis parameters\n"
21767 "\n"
21768 "DESCRIPTION:\n"
21769 "\n"
21770 " Identical to plsxax, except that arguments are flags for y axis. See\n"
21771 " the description of plsxax for more detail.\n"
21772 "\n"
21773 " Redacted form: plsyax(digmax, digits)\n"
21774 "\n"
21775 " This function is used in examples 1, 14, and 31.\n"
21776 "\n"
21777 "\n"
21778 "\n"
21779 "SYNOPSIS:\n"
21780 "\n"
21781 "plsyax(digmax, digits)\n"
21782 "\n"
21783 "ARGUMENTS:\n"
21784 "\n"
21785 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21786 " digits for the y axis. If nonzero, the printed label will be\n"
21787 " switched to a floating-point representation when the number of\n"
21788 " digits exceeds digmax.\n"
21789 "\n"
21790 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21791 " its value here has no effect since it is set only by plbox or\n"
21792 " plbox3. However, the user may obtain its value after a call to\n"
21793 " either of these functions by calling plgyax.\n"
21794 "\n"
21795 ""},
21796 { "plsym", _wrap_plsym, METH_VARARGS, "\n"
21797 "Plot a glyph at the specified points\n"
21798 "\n"
21799 "DESCRIPTION:\n"
21800 "\n"
21801 " Plot a glyph at the specified points. (This function is largely\n"
21802 " superseded by plstring which gives access to many[!] more glyphs.)\n"
21803 "\n"
21804 " Redacted form: plsym(x, y, code)\n"
21805 "\n"
21806 " This function is used in example 7.\n"
21807 "\n"
21808 "\n"
21809 "\n"
21810 "SYNOPSIS:\n"
21811 "\n"
21812 "plsym(n, x, y, code)\n"
21813 "\n"
21814 "ARGUMENTS:\n"
21815 "\n"
21816 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21817 "\n"
21818 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21819 " the points.\n"
21820 "\n"
21821 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21822 " the points.\n"
21823 "\n"
21824 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21825 " to be plotted at each of the n points.\n"
21826 "\n"
21827 ""},
21828 { "plszax", _wrap_plszax, METH_VARARGS, "\n"
21829 "Set z axis parameters\n"
21830 "\n"
21831 "DESCRIPTION:\n"
21832 "\n"
21833 " Identical to plsxax, except that arguments are flags for z axis. See\n"
21834 " the description of plsxax for more detail.\n"
21835 "\n"
21836 " Redacted form: plszax(digmax, digits)\n"
21837 "\n"
21838 " This function is used in example 31.\n"
21839 "\n"
21840 "\n"
21841 "\n"
21842 "SYNOPSIS:\n"
21843 "\n"
21844 "plszax(digmax, digits)\n"
21845 "\n"
21846 "ARGUMENTS:\n"
21847 "\n"
21848 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21849 " digits for the z axis. If nonzero, the printed label will be\n"
21850 " switched to a floating-point representation when the number of\n"
21851 " digits exceeds digmax.\n"
21852 "\n"
21853 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21854 " its value here has no effect since it is set only by plbox or\n"
21855 " plbox3. However, the user may obtain its value after a call to\n"
21856 " either of these functions by calling plgzax.\n"
21857 "\n"
21858 ""},
21859 { "pltext", _wrap_pltext, METH_NOARGS, "\n"
21860 "Switch to text screen\n"
21861 "\n"
21862 "DESCRIPTION:\n"
21863 "\n"
21864 " Sets an interactive device to text mode, used in conjunction with\n"
21865 " plgra to allow graphics and text to be interspersed. On a device\n"
21866 " which supports separate text and graphics windows, this command causes\n"
21867 " control to be switched to the text window. This can be useful for\n"
21868 " printing diagnostic messages or getting user input, which would\n"
21869 " otherwise interfere with the plots. The program must switch back to\n"
21870 " the graphics window before issuing plot commands, as the text (or\n"
21871 " console) device will probably become quite confused otherwise. If\n"
21872 " already in text mode, this command is ignored. It is also ignored on\n"
21873 " devices which only support a single window or use a different method\n"
21874 " for shifting focus (see also plgra).\n"
21875 "\n"
21876 " Redacted form: pltext()\n"
21877 "\n"
21878 " This function is used in example 1.\n"
21879 "\n"
21880 "\n"
21881 "\n"
21882 "SYNOPSIS:\n"
21883 "\n"
21884 "pltext()\n"
21885 "\n"
21886 ""},
21887 { "pltimefmt", _wrap_pltimefmt, METH_O, "\n"
21888 "Set format for date / time labels\n"
21889 "\n"
21890 "DESCRIPTION:\n"
21891 "\n"
21892 " Sets the format for date / time labels. To enable date / time format\n"
21893 " labels see the options to plbox, plbox3, and plenv.\n"
21894 "\n"
21895 " Redacted form: pltimefmt(fmt)\n"
21896 "\n"
21897 " This function is used in example 29.\n"
21898 "\n"
21899 "\n"
21900 "\n"
21901 "SYNOPSIS:\n"
21902 "\n"
21903 "pltimefmt(fmt)\n"
21904 "\n"
21905 "ARGUMENTS:\n"
21906 "\n"
21907 " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21908 " interpreted similarly to the format specifier of typical system\n"
21909 " strftime routines except that PLplot ignores locale and also\n"
21910 " supplies some useful extensions in the context of plotting. All\n"
21911 " text in the string is printed as-is other than conversion\n"
21912 " specifications which take the form of a '%' character followed by\n"
21913 " further conversion specification character. The conversion\n"
21914 " specifications which are similar to those provided by system\n"
21915 " strftime routines are the following: %a: The abbreviated (English)\n"
21916 " weekday name.\n"
21917 " %A: The full (English) weekday name.\n"
21918 " %b: The abbreviated (English) month name.\n"
21919 " %B: The full (English) month name.\n"
21920 " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21921 " %C: The century number (year/100) as a 2-digit integer.\n"
21922 " %d: The day of the month as a decimal number (range 01 to 31).\n"
21923 " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21924 " %e: Like %d, but a leading zero is replaced by a space.\n"
21925 " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21926 " %h: Equivalent to %b.\n"
21927 " %H: The hour as a decimal number using a 24-hour clock (range\n"
21928 " 00 to 23).\n"
21929 " %I: The hour as a decimal number using a 12-hour clock (range\n"
21930 " 01 to 12).\n"
21931 " %j: The day of the year as a decimal number (range 001 to\n"
21932 " 366).\n"
21933 " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21934 " 23); single digits are preceded by a blank. (See also %H.)\n"
21935 " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21936 " 12); single digits are preceded by a blank. (See also %I.)\n"
21937 " %m: The month as a decimal number (range 01 to 12).\n"
21938 " %M: The minute as a decimal number (range 00 to 59).\n"
21939 " %n: A newline character.\n"
21940 " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21941 " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21942 " %r: Equivalent to %I:%M:%S %p.\n"
21943 " %R: The time in 24-hour notation (%H:%M). For a version\n"
21944 " including the seconds, see %T below.\n"
21945 " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21946 " +0000 (UTC).\n"
21947 " %S: The second as a decimal number (range 00 to 60). (The\n"
21948 " range is up to 60 to allow for occasional leap seconds.)\n"
21949 " %t: A tab character.\n"
21950 " %T: The time in 24-hour notation (%H:%M:%S).\n"
21951 " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21952 " being 1. See also %w.\n"
21953 " %U: The week number of the current year as a decimal number,\n"
21954 " range 00 to 53, starting with the first Sunday as the first\n"
21955 " day of week 01. See also %V and %W.\n"
21956 " %v: Equivalent to %e-%b-%Y.\n"
21957 " %V: The ISO 8601 week number of the current year as a decimal\n"
21958 " number, range 01 to 53, where week 1 is the first week that\n"
21959 " has at least 4 days in the new year. See also %U and %W.\n"
21960 " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21961 " being 0. See also %u.\n"
21962 " %W: The week number of the current year as a decimal number,\n"
21963 " range 00 to 53, starting with the first Monday as the first\n"
21964 " day of week 01.\n"
21965 " %x: Equivalent to %a %b %d %Y.\n"
21966 " %X: Equivalent to %T.\n"
21967 " %y: The year as a decimal number without a century (range 00\n"
21968 " to 99).\n"
21969 " %Y: The year as a decimal number including a century.\n"
21970 " %z: The UTC time-zone string = \"+0000\".\n"
21971 " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21972 " %+: The UTC date and time in default format of the Unix date\n"
21973 " command which is equivalent to %a %b %d %T %Z %Y.\n"
21974 " %%: A literal \"%\" character.\n"
21975 " The conversion specifications which are extensions to those normally\n"
21976 " provided by system strftime routines are the following: %(0-9):\n"
21977 " The fractional part of the seconds field (including leading\n"
21978 " decimal point) to the specified accuracy. Thus %S%3 would give\n"
21979 " seconds to millisecond accuracy (00.000).\n"
21980 " %.: The fractional part of the seconds field (including\n"
21981 " leading decimal point) to the maximum available accuracy. Thus\n"
21982 " %S%. would give seconds with fractional part up to 9 decimal\n"
21983 " places if available.\n"
21984 "\n"
21985 ""},
21986 { "plvasp", _wrap_plvasp, METH_O, "\n"
21987 "Specify viewport using aspect ratio only\n"
21988 "\n"
21989 "DESCRIPTION:\n"
21990 "\n"
21991 " Selects the largest viewport with the given aspect ratio within the\n"
21992 " subpage that leaves a standard margin (left-hand margin of eight\n"
21993 " character heights, and a margin around the other three sides of five\n"
21994 " character heights).\n"
21995 "\n"
21996 " Redacted form: plvasp(aspect)\n"
21997 "\n"
21998 " This function is used in example 13.\n"
21999 "\n"
22000 "\n"
22001 "\n"
22002 "SYNOPSIS:\n"
22003 "\n"
22004 "plvasp(aspect)\n"
22005 "\n"
22006 "ARGUMENTS:\n"
22007 "\n"
22008 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22009 " axis of resulting viewport.\n"
22010 "\n"
22011 ""},
22012 { "plvect", _wrap_plvect, METH_VARARGS, "\n"
22013 "Vector plot\n"
22014 "\n"
22015 "DESCRIPTION:\n"
22016 "\n"
22017 " Draws a plot of vector data contained in the matrices (\n"
22018 " u[\n"
22019 " nx][\n"
22020 " ny],\n"
22021 " v[\n"
22022 " nx][\n"
22023 " ny]) . The scaling factor for the vectors is given by scale. A\n"
22024 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
22025 " additional data required by the transformation routine to map indices\n"
22026 " within the matrices to the world coordinates. The style of the vector\n"
22027 " arrow may be set using plsvect.\n"
22028 "\n"
22029 " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
22030 " discussion) the pltr, pltr_data callback arguments are sometimes\n"
22031 " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
22032 " with either one or two dimensions.\n"
22033 "\n"
22034 " This function is used in example 22.\n"
22035 "\n"
22036 "\n"
22037 "\n"
22038 "SYNOPSIS:\n"
22039 "\n"
22040 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
22041 "\n"
22042 "ARGUMENTS:\n"
22043 "\n"
22044 " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
22045 " and y components of the vector data to be plotted.\n"
22046 "\n"
22047 " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
22048 "\n"
22049 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
22050 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
22051 " automatically calculated for the data. If scale < 0 then the\n"
22052 " scaling factor is automatically calculated for the data and then\n"
22053 " multiplied by -\n"
22054 " scale. If scale > 0 then the scaling factor is set to scale.\n"
22055 "\n"
22056 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22057 " defines the transformation between the zero-based indices of the\n"
22058 " matrices u and v and world coordinates.For the C case,\n"
22059 " transformation functions are provided in the PLplot library: pltr0\n"
22060 " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
22061 " mappings respectively defined by vectors and matrices. In\n"
22062 " addition, C callback routines for the transformation can be\n"
22063 " supplied by the user such as the mypltr function in\n"
22064 " examples/c/x09c.c which provides a general linear transformation\n"
22065 " between index coordinates and world coordinates.For languages\n"
22066 " other than C you should consult the PLplot documentation for the\n"
22067 " details concerning how PLTRANSFORM_callback arguments are\n"
22068 " interfaced. However, in general, a particular pattern of\n"
22069 " callback-associated arguments such as a tr vector with 6 elements;\n"
22070 " xg and yg vectors; or xg and yg matrices are respectively\n"
22071 " interfaced to a linear-transformation routine similar to the above\n"
22072 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22073 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22074 " support native language callbacks for handling index to\n"
22075 " world-coordinate transformations. Examples of these various\n"
22076 " approaches are given in examples/<language>x09*,\n"
22077 " examples/<language>x16*, examples/<language>x20*,\n"
22078 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22079 " supported languages.\n"
22080 "\n"
22081 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22082 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
22083 " that is externally supplied.\n"
22084 "\n"
22085 ""},
22086 { "plvpas", _wrap_plvpas, METH_VARARGS, "\n"
22087 "Specify viewport using coordinates and aspect ratio\n"
22088 "\n"
22089 "DESCRIPTION:\n"
22090 "\n"
22091 " Device-independent routine for setting up the viewport. The viewport\n"
22092 " is chosen to be the largest with the given aspect ratio that fits\n"
22093 " within the specified region (in terms of normalized subpage\n"
22094 " coordinates). This routine is functionally equivalent to plvpor when\n"
22095 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
22096 " routine reserves no extra space at the edges for labels.\n"
22097 "\n"
22098 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22099 "\n"
22100 " This function is used in example 9.\n"
22101 "\n"
22102 "\n"
22103 "\n"
22104 "SYNOPSIS:\n"
22105 "\n"
22106 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22107 "\n"
22108 "ARGUMENTS:\n"
22109 "\n"
22110 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22111 " left-hand edge of the viewport.\n"
22112 "\n"
22113 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22114 " right-hand edge of the viewport.\n"
22115 "\n"
22116 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22117 " bottom edge of the viewport.\n"
22118 "\n"
22119 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22120 " edge of the viewport.\n"
22121 "\n"
22122 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22123 " axis.\n"
22124 "\n"
22125 ""},
22126 { "plvpor", _wrap_plvpor, METH_VARARGS, "\n"
22127 "Specify viewport using normalized subpage coordinates\n"
22128 "\n"
22129 "DESCRIPTION:\n"
22130 "\n"
22131 " Device-independent routine for setting up the viewport. This defines\n"
22132 " the viewport in terms of normalized subpage coordinates which run from\n"
22133 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
22134 " current subpage. Use the alternate routine plsvpa in order to create\n"
22135 " a viewport of a definite size.\n"
22136 "\n"
22137 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
22138 "\n"
22139 " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
22140 " 24, 26, 27, and 31.\n"
22141 "\n"
22142 "\n"
22143 "\n"
22144 "SYNOPSIS:\n"
22145 "\n"
22146 "plvpor(xmin, xmax, ymin, ymax)\n"
22147 "\n"
22148 "ARGUMENTS:\n"
22149 "\n"
22150 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22151 " left-hand edge of the viewport.\n"
22152 "\n"
22153 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22154 " right-hand edge of the viewport.\n"
22155 "\n"
22156 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22157 " bottom edge of the viewport.\n"
22158 "\n"
22159 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22160 " edge of the viewport.\n"
22161 "\n"
22162 ""},
22163 { "plvsta", _wrap_plvsta, METH_NOARGS, "\n"
22164 "Select standard viewport\n"
22165 "\n"
22166 "DESCRIPTION:\n"
22167 "\n"
22168 " Selects the largest viewport within the subpage that leaves a standard\n"
22169 " margin (left-hand margin of eight character heights, and a margin\n"
22170 " around the other three sides of five character heights).\n"
22171 "\n"
22172 " Redacted form: plvsta()\n"
22173 "\n"
22174 " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
22175 "\n"
22176 "\n"
22177 "\n"
22178 "SYNOPSIS:\n"
22179 "\n"
22180 "plvsta()\n"
22181 "\n"
22182 ""},
22183 { "plw3d", _wrap_plw3d, METH_VARARGS, "\n"
22184 "Configure the transformations required for projecting a 3D surface on a 2D window\n"
22185 "\n"
22186 "DESCRIPTION:\n"
22187 "\n"
22188 " Configure the transformations required for projecting a 3D surface on\n"
22189 " an existing 2D window. Those transformations (see the PLplot\n"
22190 " documentation) are done to a rectangular cuboid enclosing the 3D\n"
22191 " surface which has its limits expressed in 3D world coordinates and\n"
22192 " also normalized 3D coordinates (used for interpreting the altitude and\n"
22193 " azimuth of the viewing angle). The transformations consist of the\n"
22194 " linear transform from 3D world coordinates to normalized 3D\n"
22195 " coordinates, and the 3D rotation of normalized coordinates required to\n"
22196 " align the pole of the new 3D coordinate system with the viewing\n"
22197 " direction specified by altitude and azimuth so that x and y of the\n"
22198 " surface elements in that transformed coordinate system are the\n"
22199 " projection of the 3D surface with given viewing direction on the 2D\n"
22200 " window.\n"
22201 "\n"
22202 " The enclosing rectangular cuboid for the surface plot is defined by\n"
22203 " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
22204 " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
22205 " sizes of basex by basey by height so that xmin maps to -\n"
22206 " basex/2, xmax maps to basex/2, ymin maps to -\n"
22207 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
22208 " The resulting rectangular cuboid in normalized coordinates is then\n"
22209 " viewed by an observer at altitude alt and azimuth az. This routine\n"
22210 " must be called before plbox3 or any of the 3D surface plotting\n"
22211 " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
22212 " plsurf3dl or plfill3.\n"
22213 "\n"
22214 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
22215 " zmin, zmax, alt, az)\n"
22216 "\n"
22217 " This function is examples 8, 11, 18, and 21.\n"
22218 "\n"
22219 "\n"
22220 "\n"
22221 "SYNOPSIS:\n"
22222 "\n"
22223 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
22224 "\n"
22225 "ARGUMENTS:\n"
22226 "\n"
22227 " basex (PLFLT, input) : The normalized x coordinate size of the\n"
22228 " rectangular cuboid.\n"
22229 "\n"
22230 " basey (PLFLT, input) : The normalized y coordinate size of the\n"
22231 " rectangular cuboid.\n"
22232 "\n"
22233 " height (PLFLT, input) : The normalized z coordinate size of the\n"
22234 " rectangular cuboid.\n"
22235 "\n"
22236 " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
22237 " rectangular cuboid.\n"
22238 "\n"
22239 " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
22240 " rectangular cuboid.\n"
22241 "\n"
22242 " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
22243 " rectangular cuboid.\n"
22244 "\n"
22245 " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
22246 " rectangular cuboid.\n"
22247 "\n"
22248 " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
22249 " rectangular cuboid.\n"
22250 "\n"
22251 " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
22252 " rectangular cuboid.\n"
22253 "\n"
22254 " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
22255 " plane of the rectangular cuboid in normalized coordinates.\n"
22256 "\n"
22257 " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
22258 " rectangular cuboid in normalized coordinates. When az=0, the\n"
22259 " observer is looking face onto the zx plane of the rectangular\n"
22260 " cuboid in normalized coordinates, and as az is increased, the\n"
22261 " observer moves clockwise around that cuboid when viewed from above\n"
22262 " the xy plane.\n"
22263 "\n"
22264 ""},
22265 { "plwidth", _wrap_plwidth, METH_O, "\n"
22266 "Set pen width\n"
22267 "\n"
22268 "DESCRIPTION:\n"
22269 "\n"
22270 " Sets the pen width.\n"
22271 "\n"
22272 " Redacted form: plwidth(width)\n"
22273 "\n"
22274 " This function is used in examples 1 and 2.\n"
22275 "\n"
22276 "\n"
22277 "\n"
22278 "SYNOPSIS:\n"
22279 "\n"
22280 "plwidth(width)\n"
22281 "\n"
22282 "ARGUMENTS:\n"
22283 "\n"
22284 " width (PLFLT, input) : The desired pen width. If width is negative\n"
22285 " or the same as the previous value no action is taken. width = 0.\n"
22286 " should be interpreted as as the minimum valid pen width for the\n"
22287 " device. The interpretation of positive width values is also\n"
22288 " device dependent.\n"
22289 "\n"
22290 ""},
22291 { "plwind", _wrap_plwind, METH_VARARGS, "\n"
22292 "Specify window\n"
22293 "\n"
22294 "DESCRIPTION:\n"
22295 "\n"
22296 " Specify the window, i.e., the world coordinates of the edges of the\n"
22297 " viewport.\n"
22298 "\n"
22299 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
22300 "\n"
22301 " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
22302 " 29, and 31.\n"
22303 "\n"
22304 "\n"
22305 "\n"
22306 "SYNOPSIS:\n"
22307 "\n"
22308 "plwind(xmin, xmax, ymin, ymax)\n"
22309 "\n"
22310 "ARGUMENTS:\n"
22311 "\n"
22312 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
22313 " of the viewport.\n"
22314 "\n"
22315 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
22316 " of the viewport.\n"
22317 "\n"
22318 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
22319 " the viewport.\n"
22320 "\n"
22321 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
22322 " viewport.\n"
22323 "\n"
22324 ""},
22325 { "plxormod", _wrap_plxormod, METH_O, "\n"
22326 "Enter or leave xor mode\n"
22327 "\n"
22328 "DESCRIPTION:\n"
22329 "\n"
22330 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
22331 " those drivers (e.g., the xwin driver) that support it. Enables\n"
22332 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
22333 " is not capable of xor operation it returns a status of false.\n"
22334 "\n"
22335 " Redacted form: plxormod(mode, status)\n"
22336 "\n"
22337 " This function is used in examples 1 and 20.\n"
22338 "\n"
22339 "\n"
22340 "\n"
22341 "SYNOPSIS:\n"
22342 "\n"
22343 "plxormod(mode, status)\n"
22344 "\n"
22345 "ARGUMENTS:\n"
22346 "\n"
22347 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
22348 " is false means leave xor mode.\n"
22349 "\n"
22350 " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
22351 " modestatus of true (false) means driver is capable (incapable) of\n"
22352 " xor mode.\n"
22353 "\n"
22354 ""},
22355 { "plmap", _wrap_plmap, METH_VARARGS, "\n"
22356 "Plot continental outline or shapefile data in world coordinates\n"
22357 "\n"
22358 "DESCRIPTION:\n"
22359 "\n"
22360 " Plots continental outlines or shapefile data in world coordinates. A\n"
22361 " demonstration of how to use this function to create different\n"
22362 " projections can be found in examples/c/x19c. PLplot is provided with\n"
22363 " basic coastal outlines and USA state borders. To use the map\n"
22364 " functionality PLplot must be compiled with the shapelib library.\n"
22365 " Shapefiles have become a popular standard for geographical data and\n"
22366 " data in this format can be easily found from a number of online\n"
22367 " sources. Shapefile data is actually provided as three or more files\n"
22368 " with the same filename, but different extensions. The .shp and .shx\n"
22369 " files are required for plotting Shapefile data with PLplot.\n"
22370 "\n"
22371 " PLplot currently supports the point, multipoint, polyline and polygon\n"
22372 " objects within shapefiles. However holes in polygons are not\n"
22373 " supported. When plmap is used the type of object is derived from the\n"
22374 " shapefile, if you wish to override the type then use one of the other\n"
22375 " plmap variants. The built in maps have line data only.\n"
22376 "\n"
22377 " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
22378 "\n"
22379 " This function is used in example 19.\n"
22380 "\n"
22381 "\n"
22382 "\n"
22383 "SYNOPSIS:\n"
22384 "\n"
22385 "plmap(mapform, name, minx, maxx, miny, maxy)\n"
22386 "\n"
22387 "ARGUMENTS:\n"
22388 "\n"
22389 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22390 " transform the original map data coordinates to a new coordinate\n"
22391 " system. The PLplot-supplied map data is provided as latitudes and\n"
22392 " longitudes; other Shapefile data may be provided in other\n"
22393 " coordinate systems as can be found in their .prj plain text files.\n"
22394 " For example, by using this transform we can change from a\n"
22395 " longitude, latitude coordinate to a polar stereographic\n"
22396 " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
22397 " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
22398 " corresponding y coordinates (latitudes for the PLplot supplied\n"
22399 " data). After the call to mapform(), x[] and y[] should be\n"
22400 " replaced by the corresponding plot coordinates. If no transform is\n"
22401 " desired, mapform can be replaced by NULL.\n"
22402 "\n"
22403 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22404 " the type of map plotted. This is either one of the PLplot built-in\n"
22405 " maps or the file name of a set of Shapefile files without the file\n"
22406 " extensions. For the PLplot built-in maps the possible values are:\n"
22407 " \"globe\" -- continental outlines\n"
22408 " \"usa\" -- USA and state boundaries\n"
22409 " \"cglobe\" -- continental outlines and countries\n"
22410 " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
22411 "\n"
22412 "\n"
22413 " minx (PLFLT, input) : The minimum x value of map elements to be\n"
22414 " drawn. The units must match the shapefile (built in maps are\n"
22415 " degrees lat/lon). Objects in the file which do not encroach on the\n"
22416 " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
22417 " note this is simply an optimisation, not a clipping so for objects\n"
22418 " with some points inside the box and some points outside the box\n"
22419 " all the points will be rendered. These parameters also define\n"
22420 " latitude and longitude wrapping for shapefiles using these units.\n"
22421 " Longitude points will be wrapped by integer multiples of 360\n"
22422 " degrees to place them in the box. This allows the same data to be\n"
22423 " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
22424 " you plot from -180-540 you will get two cycles of data drawn. The\n"
22425 " value of minx must be less than the value of maxx. Passing in a\n"
22426 " nan, max/-max floating point number or +/-infinity will case the\n"
22427 " bounding box from the shapefile to be used.\n"
22428 "\n"
22429 " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22430 " drawn - see minx.\n"
22431 "\n"
22432 " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22433 " drawn - see minx.\n"
22434 "\n"
22435 " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22436 " drawn - see minx.\n"
22437 "\n"
22438 ""},
22439 { "plmapline", _wrap_plmapline, METH_VARARGS, "\n"
22440 "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22441 "\n"
22442 "DESCRIPTION:\n"
22443 "\n"
22444 " Plot all or a subset of Shapefile data using lines in world\n"
22445 " coordinates. Our 19th standard example demonstrates how to use this\n"
22446 " function. This function plots data from a Shapefile using lines as in\n"
22447 " plmap, however it also has the option of also only drawing specified\n"
22448 " elements from the Shapefile. The vector of indices of the required\n"
22449 " elements are passed as a function argument. The Shapefile data should\n"
22450 " include a metadata file (extension.dbf) listing all items within the\n"
22451 " Shapefile. This file can be opened by most popular spreadsheet\n"
22452 " programs and can be used to decide which indices to pass to this\n"
22453 " function.\n"
22454 "\n"
22455 " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22456 " plotentries)\n"
22457 "\n"
22458 " This function is used in example 19.\n"
22459 "\n"
22460 "\n"
22461 "\n"
22462 "SYNOPSIS:\n"
22463 "\n"
22464 "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22465 "\n"
22466 "ARGUMENTS:\n"
22467 "\n"
22468 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22469 " transform the coordinates given in the shapefile into a plot\n"
22470 " coordinate system. By using this transform, we can change from a\n"
22471 " longitude, latitude coordinate to a polar stereographic project,\n"
22472 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22473 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22474 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22475 " plot coordinates. If no transform is desired, mapform can be\n"
22476 " replaced by NULL.\n"
22477 "\n"
22478 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22479 " the file name of a set of Shapefile files without the file\n"
22480 " extension.\n"
22481 "\n"
22482 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22483 " be in the same units as used by the Shapefile. You could use a\n"
22484 " very large negative number to plot everything, but you can improve\n"
22485 " performance by limiting the area drawn. The units must match those\n"
22486 " of the Shapefile projection, which may be for example longitude or\n"
22487 " distance. The value of minx must be less than the value of maxx.\n"
22488 "\n"
22489 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22490 " use a very large number to plot everything, but you can improve\n"
22491 " performance by limiting the area drawn.\n"
22492 "\n"
22493 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22494 " be in the same units as used by the Shapefile. You could use a\n"
22495 " very large negative number to plot everything, but you can improve\n"
22496 " performance by limiting the area drawn. The units must match those\n"
22497 " of the Shapefile projection, which may be for example latitude or\n"
22498 " distance. The value of miny must be less than the value of maxy.\n"
22499 "\n"
22500 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22501 " use a very large number to plot everything, but you can improve\n"
22502 " performance by limiting the area drawn.\n"
22503 "\n"
22504 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22505 " zero-based indices of the Shapefile elements which will be drawn.\n"
22506 " Setting\n"
22507 " plotentries to NULL will plot all elements of the Shapefile.\n"
22508 "\n"
22509 " nplotentries (PLINT, input) : The number of items in\n"
22510 " plotentries. Ignored if\n"
22511 " plotentries is NULL.\n"
22512 "\n"
22513 ""},
22514 { "plmapstring", _wrap_plmapstring, METH_VARARGS, "\n"
22515 "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22516 "\n"
22517 "DESCRIPTION:\n"
22518 "\n"
22519 " As per plmapline, however the items are plotted as strings or points\n"
22520 " in the same way as plstring.\n"
22521 "\n"
22522 " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22523 " maxy, plotentries)\n"
22524 "\n"
22525 " This function is not used in any examples.\n"
22526 "\n"
22527 "\n"
22528 "\n"
22529 "SYNOPSIS:\n"
22530 "\n"
22531 "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22532 "\n"
22533 "ARGUMENTS:\n"
22534 "\n"
22535 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22536 " transform the coordinates given in the shapefile into a plot\n"
22537 " coordinate system. By using this transform, we can change from a\n"
22538 " longitude, latitude coordinate to a polar stereographic project,\n"
22539 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22540 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22541 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22542 " plot coordinates. If no transform is desired, mapform can be\n"
22543 " replaced by NULL.\n"
22544 "\n"
22545 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22546 " the file name of a set of Shapefile files without the file\n"
22547 " extension.\n"
22548 "\n"
22549 " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22550 " drawn.\n"
22551 "\n"
22552 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22553 " be in the same units as used by the Shapefile. You could use a\n"
22554 " very large negative number to plot everything, but you can improve\n"
22555 " performance by limiting the area drawn. The units must match those\n"
22556 " of the Shapefile projection, which may be for example longitude or\n"
22557 " distance. The value of minx must be less than the value of maxx.\n"
22558 "\n"
22559 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22560 " use a very large number to plot everything, but you can improve\n"
22561 " performance by limiting the area drawn.\n"
22562 "\n"
22563 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22564 " be in the same units as used by the Shapefile. You could use a\n"
22565 " very large negative number to plot everything, but you can improve\n"
22566 " performance by limiting the area drawn. The units must match those\n"
22567 " of the Shapefile projection, which may be for example latitude or\n"
22568 " distance. The value of miny must be less than the value of maxy.\n"
22569 "\n"
22570 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22571 " use a very large number to plot everything, but you can improve\n"
22572 " performance by limiting the area drawn.\n"
22573 "\n"
22574 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22575 " zero-based indices of the Shapefile elements which will be drawn.\n"
22576 " Setting\n"
22577 " plotentries to NULL will plot all elements of the Shapefile.\n"
22578 "\n"
22579 " nplotentries (PLINT, input) : The number of items in\n"
22580 " plotentries. Ignored if\n"
22581 " plotentries is NULL.\n"
22582 "\n"
22583 ""},
22584 { "plmaptex", _wrap_plmaptex, METH_VARARGS, "\n"
22585 "Draw text at points defined by Shapefile data in world coordinates\n"
22586 "\n"
22587 "DESCRIPTION:\n"
22588 "\n"
22589 " As per plmapline, however the items are plotted as text in the same\n"
22590 " way as plptex.\n"
22591 "\n"
22592 " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22593 " miny, maxy, plotentry)\n"
22594 "\n"
22595 " This function is used in example 19.\n"
22596 "\n"
22597 "\n"
22598 "\n"
22599 "SYNOPSIS:\n"
22600 "\n"
22601 "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22602 "\n"
22603 "ARGUMENTS:\n"
22604 "\n"
22605 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22606 " transform the coordinates given in the shapefile into a plot\n"
22607 " coordinate system. By using this transform, we can change from a\n"
22608 " longitude, latitude coordinate to a polar stereographic project,\n"
22609 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22610 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22611 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22612 " plot coordinates. If no transform is desired, mapform can be\n"
22613 " replaced by NULL.\n"
22614 "\n"
22615 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22616 " the file name of a set of Shapefile files without the file\n"
22617 " extension.\n"
22618 "\n"
22619 " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22620 " dy/dx.\n"
22621 "\n"
22622 " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22623 " dy/dx.\n"
22624 "\n"
22625 " just (PLFLT, input) : Set the justification of the text. The value\n"
22626 " given will be the fraction of the distance along the string that\n"
22627 " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22628 " centralized text and 1.0 gives right aligned text.\n"
22629 "\n"
22630 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22631 "\n"
22632 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22633 " be in the same units as used by the Shapefile. You could use a\n"
22634 " very large negative number to plot everything, but you can improve\n"
22635 " performance by limiting the area drawn. The units must match those\n"
22636 " of the Shapefile projection, which may be for example longitude or\n"
22637 " distance. The value of minx must be less than the value of maxx.\n"
22638 "\n"
22639 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22640 " use a very large number to plot everything, but you can improve\n"
22641 " performance by limiting the area drawn.\n"
22642 "\n"
22643 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22644 " be in the same units as used by the Shapefile. You could use a\n"
22645 " very large negative number to plot everything, but you can improve\n"
22646 " performance by limiting the area drawn. The units must match those\n"
22647 " of the Shapefile projection, which may be for example latitude or\n"
22648 " distance. The value of miny must be less than the value of maxy.\n"
22649 "\n"
22650 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22651 " use a very large number to plot everything, but you can improve\n"
22652 " performance by limiting the area drawn.\n"
22653 "\n"
22654 " plotentry (PLINT, input) : An integer indicating which text string\n"
22655 " of the Shapefile (zero indexed) will be drawn.\n"
22656 "\n"
22657 ""},
22658 { "plmapfill", _wrap_plmapfill, METH_VARARGS, "\n"
22659 "Plot all or a subset of Shapefile data, filling the polygons\n"
22660 "\n"
22661 "DESCRIPTION:\n"
22662 "\n"
22663 " As per plmapline, however the items are filled in the same way as\n"
22664 " plfill.\n"
22665 "\n"
22666 " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22667 " plotentries)\n"
22668 "\n"
22669 " This function is used in example 19.\n"
22670 "\n"
22671 "\n"
22672 "\n"
22673 "SYNOPSIS:\n"
22674 "\n"
22675 "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22676 "\n"
22677 "ARGUMENTS:\n"
22678 "\n"
22679 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22680 " transform the coordinates given in the shapefile into a plot\n"
22681 " coordinate system. By using this transform, we can change from a\n"
22682 " longitude, latitude coordinate to a polar stereographic project,\n"
22683 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22684 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22685 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22686 " plot coordinates. If no transform is desired, mapform can be\n"
22687 " replaced by NULL.\n"
22688 "\n"
22689 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22690 " the file name of a set of Shapefile files without the file\n"
22691 " extension.\n"
22692 "\n"
22693 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22694 " be in the same units as used by the Shapefile. You could use a\n"
22695 " very large negative number to plot everything, but you can improve\n"
22696 " performance by limiting the area drawn. The units must match those\n"
22697 " of the Shapefile projection, which may be for example longitude or\n"
22698 " distance. The value of minx must be less than the value of maxx.\n"
22699 "\n"
22700 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22701 " use a very large number to plot everything, but you can improve\n"
22702 " performance by limiting the area drawn.\n"
22703 "\n"
22704 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22705 " be in the same units as used by the Shapefile. You could use a\n"
22706 " very large negative number to plot everything, but you can improve\n"
22707 " performance by limiting the area drawn. The units must match those\n"
22708 " of the Shapefile projection, which may be for example latitude or\n"
22709 " distance. The value of miny must be less than the value of maxy.\n"
22710 "\n"
22711 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22712 " use a very large number to plot everything, but you can improve\n"
22713 " performance by limiting the area drawn.\n"
22714 "\n"
22715 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22716 " zero-based indices of the Shapefile elements which will be drawn.\n"
22717 " Setting\n"
22718 " plotentries to NULL will plot all elements of the Shapefile.\n"
22719 "\n"
22720 " nplotentries (PLINT, input) : The number of items in\n"
22721 " plotentries. Ignored if\n"
22722 " plotentries is NULL.\n"
22723 "\n"
22724 ""},
22725 { "plmeridians", _wrap_plmeridians, METH_VARARGS, "\n"
22726 "Plot latitude and longitude lines\n"
22727 "\n"
22728 "DESCRIPTION:\n"
22729 "\n"
22730 " Displays latitude and longitude on the current plot. The lines are\n"
22731 " plotted in the current color and line style.\n"
22732 "\n"
22733 " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22734 " minlat, maxlat)\n"
22735 "\n"
22736 " This function is used in example 19.\n"
22737 "\n"
22738 "\n"
22739 "\n"
22740 "SYNOPSIS:\n"
22741 "\n"
22742 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22743 "\n"
22744 "ARGUMENTS:\n"
22745 "\n"
22746 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22747 " transform the coordinate longitudes and latitudes to a plot\n"
22748 " coordinate system. By using this transform, we can change from a\n"
22749 " longitude, latitude coordinate to a polar stereographic project,\n"
22750 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22751 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22752 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22753 " plot coordinates. If no transform is desired, mapform can be\n"
22754 " replaced by NULL.\n"
22755 "\n"
22756 " dlong (PLFLT, input) : The interval in degrees at which the\n"
22757 " longitude lines are to be plotted.\n"
22758 "\n"
22759 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22760 " lines are to be plotted.\n"
22761 "\n"
22762 " minlong (PLFLT, input) : The value of the longitude on the left\n"
22763 " side of the plot. The value of minlong must be less than the value\n"
22764 " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22765 " equal to 360.\n"
22766 "\n"
22767 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22768 " side of the plot.\n"
22769 "\n"
22770 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22771 " background. One can always use -90.0 as the boundary outside the\n"
22772 " plot window will be automatically eliminated. However, the\n"
22773 " program will be faster if one can reduce the size of the\n"
22774 " background plotted.\n"
22775 "\n"
22776 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22777 " background. One can always use 90.0 as the boundary outside the\n"
22778 " plot window will be automatically eliminated.\n"
22779 "\n"
22780 ""},
22781 { "plimage", _wrap_plimage, METH_VARARGS, "\n"
22782 "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22783 "\n"
22784 "DESCRIPTION:\n"
22785 "\n"
22786 " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22787 " automatically adjusted to use the maximum and minimum values in idata\n"
22788 " as valuemin and valuemax in a call to plimagefr.\n"
22789 "\n"
22790 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22791 " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22792 "\n"
22793 "\n"
22794 " This function is used in example 20.\n"
22795 "\n"
22796 "\n"
22797 "\n"
22798 "SYNOPSIS:\n"
22799 "\n"
22800 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22801 "\n"
22802 "ARGUMENTS:\n"
22803 "\n"
22804 " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22805 " to plot. Should have dimensions of\n"
22806 " nx by\n"
22807 " ny.\n"
22808 "\n"
22809 " nx, ny (PLINT, input) : Dimensions of idata\n"
22810 "\n"
22811 " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22812 " are linearly transformed to these world coordinate ranges such\n"
22813 " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22814 " - 1] corresponds to (xmax, ymax).\n"
22815 "\n"
22816 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22817 " (inclusive) will be plotted.\n"
22818 "\n"
22819 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22820 " points whose plot coordinates fall inside the window of (Dxmin,\n"
22821 " Dymin) to (Dxmax, Dymax).\n"
22822 "\n"
22823 ""},
22824 { "plimagefr", _wrap_plimagefr, METH_VARARGS, "\n"
22825 "Plot a 2D matrix using cmap1\n"
22826 "\n"
22827 "DESCRIPTION:\n"
22828 "\n"
22829 " Plot a 2D matrix using cmap1.\n"
22830 "\n"
22831 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22832 " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22833 "\n"
22834 "\n"
22835 " This function is used in example 20.\n"
22836 "\n"
22837 "\n"
22838 "\n"
22839 "SYNOPSIS:\n"
22840 "\n"
22841 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22842 "\n"
22843 "ARGUMENTS:\n"
22844 "\n"
22845 " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22846 " plot. Should have dimensions of\n"
22847 " nx by\n"
22848 " ny.\n"
22849 "\n"
22850 " nx, ny (PLINT, input) : Dimensions of idata\n"
22851 "\n"
22852 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22853 " pltr below for how these arguments are used (only for the special case\n"
22854 " when the callback function\n"
22855 " pltr is not supplied).\n"
22856 "\n"
22857 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22858 " (inclusive) will be plotted.\n"
22859 "\n"
22860 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22861 " values to use for value to color mappings. A datum equal to or\n"
22862 " less than valuemin will be plotted with color 0.0, while a datum\n"
22863 " equal to or greater than valuemax will be plotted with color 1.0.\n"
22864 " Data between valuemin and valuemax map linearly to colors in the\n"
22865 " range (0.0-1.0).\n"
22866 "\n"
22867 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22868 " defines the transformation between the zero-based indices of the\n"
22869 " matrix idata and world coordinates. If\n"
22870 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22871 " indices of idata are mapped to the range\n"
22872 " xmin through\n"
22873 " xmax and the y indices of idata are mapped to the range\n"
22874 " ymin through\n"
22875 " ymax.For the C case, transformation functions are provided in the\n"
22876 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22877 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22878 " matrices. In addition, C callback routines for the transformation\n"
22879 " can be supplied by the user such as the mypltr function in\n"
22880 " examples/c/x09c.c which provides a general linear transformation\n"
22881 " between index coordinates and world coordinates.For languages\n"
22882 " other than C you should consult the PLplot documentation for the\n"
22883 " details concerning how PLTRANSFORM_callback arguments are\n"
22884 " interfaced. However, in general, a particular pattern of\n"
22885 " callback-associated arguments such as a tr vector with 6 elements;\n"
22886 " xg and yg vectors; or xg and yg matrices are respectively\n"
22887 " interfaced to a linear-transformation routine similar to the above\n"
22888 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22889 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22890 " support native language callbacks for handling index to\n"
22891 " world-coordinate transformations. Examples of these various\n"
22892 " approaches are given in examples/<language>x09*,\n"
22893 " examples/<language>x16*, examples/<language>x20*,\n"
22894 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22895 " supported languages.\n"
22896 "\n"
22897 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22898 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22899 " externally supplied.\n"
22900 "\n"
22901 ""},
22902 { "plClearOpts", _wrap_plClearOpts, METH_NOARGS, NULL},
22903 { "plResetOpts", _wrap_plResetOpts, METH_NOARGS, NULL},
22904 { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22905 { "plOptUsage", _wrap_plOptUsage, METH_NOARGS, NULL},
22906 { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_O, NULL},
22907 { "plGetCursor", _wrap_plGetCursor, METH_O, "\n"
22908 "Wait for graphics input event and translate to world coordinates.\n"
22909 "\n"
22910 "DESCRIPTION:\n"
22911 "\n"
22912 " Wait for graphics input event and translate to world coordinates.\n"
22913 " Returns 0 if no translation to world coordinates is possible.\n"
22914 "\n"
22915 " This function returns 1 on success and 0 if no translation to world\n"
22916 " coordinates is possible.\n"
22917 "\n"
22918 " Redacted form: plGetCursor(gin)\n"
22919 "\n"
22920 " This function is used in examples 1 and 20.\n"
22921 "\n"
22922 "\n"
22923 "\n"
22924 "SYNOPSIS:\n"
22925 "\n"
22926 "PLINT plGetCursor(gin)\n"
22927 "\n"
22928 "ARGUMENTS:\n"
22929 "\n"
22930 " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22931 " which will contain the output. The structure is not allocated by\n"
22932 " the routine and must exist before the function is called.\n"
22933 "\n"
22934 ""},
22935 { NULL, NULL, 0, NULL }
22936};
22937
22938
22939/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22940
22941static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22942static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22943static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22944static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22945static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
22946static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
22947static 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};
22948static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void = {"_p_f_int_double_p_char_int_p_void__void", "label_func|void (*)(int,double,char *,int,void *)", 0, 0, (void*)0, 0};
22949static 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};
22950static 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", "fill_func|void (*)(int,double const *,double const *)", 0, 0, (void*)0, 0};
22951static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
22952static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22953static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22954static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
22955
22972
22973static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22974static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22975static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22976static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22977static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
22983static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22984static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
22985static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
22986static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22987
23004
23005
23006/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23007
23009{0, 0, 0, 0.0, 0, 0}};
23010
23011#ifdef __cplusplus
23012}
23013#endif
23014/* -----------------------------------------------------------------------------
23015 * Type initialization:
23016 * This problem is tough by the requirement that no dynamic
23017 * memory is used. Also, since swig_type_info structures store pointers to
23018 * swig_cast_info structures and swig_cast_info structures store pointers back
23019 * to swig_type_info structures, we need some lookup code at initialization.
23020 * The idea is that swig generates all the structures that are needed.
23021 * The runtime then collects these partially filled structures.
23022 * The SWIG_InitializeModule function takes these initial arrays out of
23023 * swig_module, and does all the lookup, filling in the swig_module.types
23024 * array with the correct data and linking the correct swig_cast_info
23025 * structures together.
23026 *
23027 * The generated swig_type_info structures are assigned statically to an initial
23028 * array. We just loop through that array, and handle each type individually.
23029 * First we lookup if this type has been already loaded, and if so, use the
23030 * loaded structure instead of the generated one. Then we have to fill in the
23031 * cast linked list. The cast data is initially stored in something like a
23032 * two-dimensional array. Each row corresponds to a type (there are the same
23033 * number of rows as there are in the swig_type_initial array). Each entry in
23034 * a column is one of the swig_cast_info structures for that type.
23035 * The cast_initial array is actually an array of arrays, because each row has
23036 * a variable number of columns. So to actually build the cast linked list,
23037 * we find the array of casts associated with the type, and loop through it
23038 * adding the casts to the list. The one last trick we need to do is making
23039 * sure the type pointer in the swig_cast_info struct is correct.
23040 *
23041 * First off, we lookup the cast->type name to see if it is already loaded.
23042 * There are three cases to handle:
23043 * 1) If the cast->type has already been loaded AND the type we are adding
23044 * casting info to has not been loaded (it is in this module), THEN we
23045 * replace the cast->type pointer with the type pointer that has already
23046 * been loaded.
23047 * 2) If BOTH types (the one we are adding casting info to, and the
23048 * cast->type) are loaded, THEN the cast info has already been loaded by
23049 * the previous module so we just ignore it.
23050 * 3) Finally, if cast->type has not already been loaded, then we add that
23051 * swig_cast_info to the linked list (because the cast->type) pointer will
23052 * be correct.
23053 * ----------------------------------------------------------------------------- */
23054
23055#ifdef __cplusplus
23056extern "C" {
23057#if 0
23058} /* c-mode */
23059#endif
23060#endif
23061
23062#if 0
23063#define SWIGRUNTIME_DEBUG
23064#endif
23065
23066#ifndef SWIG_INIT_CLIENT_DATA_TYPE
23067#define SWIG_INIT_CLIENT_DATA_TYPE void *
23068#endif
23069
23070SWIGRUNTIME void
23072 size_t i;
23073 swig_module_info *module_head, *iter;
23074 int init;
23075
23076 /* check to see if the circular list has been setup, if not, set it up */
23077 if (swig_module.next==0) {
23078 /* Initialize the swig_module */
23082 init = 1;
23083 } else {
23084 init = 0;
23085 }
23086
23087 /* Try and load any already created modules */
23088 module_head = SWIG_GetModule(clientdata);
23089 if (!module_head) {
23090 /* This is the first module loaded for this interpreter */
23091 /* so set the swig module into the interpreter */
23092 SWIG_SetModule(clientdata, &swig_module);
23093 } else {
23094 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
23095 iter=module_head;
23096 do {
23097 if (iter==&swig_module) {
23098 /* Our module is already in the list, so there's nothing more to do. */
23099 return;
23100 }
23101 iter=iter->next;
23102 } while (iter!= module_head);
23103
23104 /* otherwise we must add our module into the list */
23105 swig_module.next = module_head->next;
23106 module_head->next = &swig_module;
23107 }
23108
23109 /* When multiple interpreters are used, a module could have already been initialized in
23110 a different interpreter, but not yet have a pointer in this interpreter.
23111 In this case, we do not want to continue adding types... everything should be
23112 set up already */
23113 if (init == 0) return;
23114
23115 /* Now work on filling in swig_module.types */
23116#ifdef SWIGRUNTIME_DEBUG
23117 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
23118#endif
23119 for (i = 0; i < swig_module.size; ++i) {
23120 swig_type_info *type = 0;
23121 swig_type_info *ret;
23122 swig_cast_info *cast;
23123
23124#ifdef SWIGRUNTIME_DEBUG
23125 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23126#endif
23127
23128 /* if there is another module already loaded */
23129 if (swig_module.next != &swig_module) {
23131 }
23132 if (type) {
23133 /* Overwrite clientdata field */
23134#ifdef SWIGRUNTIME_DEBUG
23135 printf("SWIG_InitializeModule: found type %s\n", type->name);
23136#endif
23138 type->clientdata = swig_module.type_initial[i]->clientdata;
23139#ifdef SWIGRUNTIME_DEBUG
23140 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23141#endif
23142 }
23143 } else {
23144 type = swig_module.type_initial[i];
23145 }
23146
23147 /* Insert casting types */
23148 cast = swig_module.cast_initial[i];
23149 while (cast->type) {
23150 /* Don't need to add information already in the list */
23151 ret = 0;
23152#ifdef SWIGRUNTIME_DEBUG
23153 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23154#endif
23155 if (swig_module.next != &swig_module) {
23157#ifdef SWIGRUNTIME_DEBUG
23158 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23159#endif
23160 }
23161 if (ret) {
23162 if (type == swig_module.type_initial[i]) {
23163#ifdef SWIGRUNTIME_DEBUG
23164 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23165#endif
23166 cast->type = ret;
23167 ret = 0;
23168 } else {
23169 /* Check for casting already in the list */
23170 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23171#ifdef SWIGRUNTIME_DEBUG
23172 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23173#endif
23174 if (!ocast) ret = 0;
23175 }
23176 }
23177
23178 if (!ret) {
23179#ifdef SWIGRUNTIME_DEBUG
23180 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23181#endif
23182 if (type->cast) {
23183 type->cast->prev = cast;
23184 cast->next = type->cast;
23185 }
23186 type->cast = cast;
23187 }
23188 cast++;
23189 }
23190 /* Set entry in modules->types array equal to the type */
23191 swig_module.types[i] = type;
23192 }
23193 swig_module.types[i] = 0;
23194
23195#ifdef SWIGRUNTIME_DEBUG
23196 printf("**** SWIG_InitializeModule: Cast List ******\n");
23197 for (i = 0; i < swig_module.size; ++i) {
23198 int j = 0;
23200 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23201 while (cast->type) {
23202 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23203 cast++;
23204 ++j;
23205 }
23206 printf("---- Total casts: %d\n",j);
23207 }
23208 printf("**** SWIG_InitializeModule: Cast List ******\n");
23209#endif
23210}
23211
23212/* This function will propagate the clientdata field of type to
23213* any new swig_type_info structures that have been added into the list
23214* of equivalent types. It is like calling
23215* SWIG_TypeClientData(type, clientdata) a second time.
23216*/
23217SWIGRUNTIME void
23219 size_t i;
23220 swig_cast_info *equiv;
23221 static int init_run = 0;
23222
23223 if (init_run) return;
23224 init_run = 1;
23225
23226 for (i = 0; i < swig_module.size; i++) {
23227 if (swig_module.types[i]->clientdata) {
23228 equiv = swig_module.types[i]->cast;
23229 while (equiv) {
23230 if (!equiv->converter) {
23231 if (equiv->type && !equiv->type->clientdata)
23233 }
23234 equiv = equiv->next;
23235 }
23236 }
23237 }
23238}
23239
23240#ifdef __cplusplus
23241#if 0
23242{
23243 /* c-mode */
23244#endif
23245}
23246#endif
23247
23248
23249
23250#ifdef __cplusplus
23251extern "C" {
23252#endif
23253
23254 /* -----------------------------------------------------------------------------
23255 * constants/methods manipulation
23256 * ----------------------------------------------------------------------------- */
23257
23258 /* Install Constants */
23259 SWIGINTERN void
23261 PyObject *obj = 0;
23262 size_t i;
23263 for (i = 0; constants[i].type; ++i) {
23264 switch(constants[i].type) {
23265 case SWIG_PY_POINTER:
23266 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23267 break;
23268 case SWIG_PY_BINARY:
23269 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23270 break;
23271 default:
23272 obj = 0;
23273 break;
23274 }
23275 if (obj) {
23276 PyDict_SetItemString(d, constants[i].name, obj);
23277 Py_DECREF(obj);
23278 }
23279 }
23280 }
23281
23282 /* -----------------------------------------------------------------------------
23283 * Patch %callback methods' docstrings to hold the callback ptrs
23284 * -----------------------------------------------------------------------------*/
23285
23286 SWIGINTERN void
23287 SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
23288 size_t i;
23289 for (i = 0; methods[i].ml_name; ++i) {
23290 const char *c = methods[i].ml_doc;
23291 if (!c) continue;
23292 c = strstr(c, "swig_ptr: ");
23293 if (c) {
23294 int j;
23295 const swig_const_info *ci = 0;
23296 const char *name = c + 10;
23297 for (j = 0; const_table[j].type; ++j) {
23298 if (strncmp(const_table[j].name, name,
23299 strlen(const_table[j].name)) == 0) {
23300 ci = &(const_table[j]);
23301 break;
23302 }
23303 }
23304 if (ci) {
23305 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23306 if (ptr) {
23307 size_t shift = (ci->ptype) - types;
23308 swig_type_info *ty = types_initial[shift];
23309 size_t ldoc = (c - methods[i].ml_doc);
23310 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23311 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23312 if (ndoc) {
23313 char *buff = ndoc;
23314 memcpy(buff, methods[i].ml_doc, ldoc);
23315 buff += ldoc;
23316 memcpy(buff, "swig_ptr: ", 10);
23317 buff += 10;
23318 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23319 methods[i].ml_doc = ndoc;
23320 }
23321 }
23322 }
23323 }
23324 }
23325 }
23326
23327#ifdef __cplusplus
23328}
23329#endif
23330
23331
23332
23333
23334/* -----------------------------------------------------------------------------*
23335 * Partial Init method
23336 * -----------------------------------------------------------------------------*/
23337
23338#ifdef __cplusplus
23339extern "C"
23340#endif
23341
23343#if PY_VERSION_HEX >= 0x03000000
23344PyObject*
23345#else
23346void
23347#endif
23349 PyObject *m, *d, *md, *globals;
23350
23351#if PY_VERSION_HEX >= 0x03000000
23352 static struct PyModuleDef SWIG_module = {
23353 PyModuleDef_HEAD_INIT,
23354 SWIG_name,
23355 NULL,
23356 -1,
23358 NULL,
23359 NULL,
23360 NULL,
23361 NULL
23362 };
23363#endif
23364
23365#if defined(SWIGPYTHON_BUILTIN)
23366 static SwigPyClientData SwigPyObject_clientdata = {
23367 0, 0, 0, 0, 0, 0, 0
23368 };
23369 static PyGetSetDef this_getset_def = {
23370 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23371 };
23372 static SwigPyGetSet thisown_getset_closure = {
23375 };
23376 static PyGetSetDef thisown_getset_def = {
23377 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23378 };
23379 PyTypeObject *builtin_pytype;
23380 int builtin_base_count;
23381 swig_type_info *builtin_basetype;
23382 PyObject *tuple;
23383 PyGetSetDescrObject *static_getset;
23384 PyTypeObject *metatype;
23385 PyTypeObject *swigpyobject;
23386 SwigPyClientData *cd;
23387 PyObject *public_interface, *public_symbol;
23388 PyObject *this_descr;
23389 PyObject *thisown_descr;
23390 PyObject *self = 0;
23391 int i;
23392
23393 (void)builtin_pytype;
23394 (void)builtin_base_count;
23395 (void)builtin_basetype;
23396 (void)tuple;
23397 (void)static_getset;
23398 (void)self;
23399
23400 /* Metaclass is used to implement static member variables */
23401 metatype = SwigPyObjectType();
23402 assert(metatype);
23403#endif
23404
23405 (void)globals;
23406
23407 /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
23408 SWIG_This();
23411#ifndef SWIGPYTHON_BUILTIN
23413#endif
23414
23415 /* Fix SwigMethods to carry the callback ptrs when needed */
23417
23418#if PY_VERSION_HEX >= 0x03000000
23419 m = PyModule_Create(&SWIG_module);
23420#else
23421 m = Py_InitModule(SWIG_name, SwigMethods);
23422#endif
23423
23424 md = d = PyModule_GetDict(m);
23425 (void)md;
23426
23428
23429#ifdef SWIGPYTHON_BUILTIN
23430 swigpyobject = SwigPyObject_TypeOnce();
23431
23432 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23433 assert(SwigPyObject_stype);
23434 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23435 if (!cd) {
23436 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23437 SwigPyObject_clientdata.pytype = swigpyobject;
23438 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
23439 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23440# if PY_VERSION_HEX >= 0x03000000
23441 return NULL;
23442# else
23443 return;
23444# endif
23445 }
23446
23447 /* All objects have a 'this' attribute */
23448 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23449 (void)this_descr;
23450
23451 /* All objects have a 'thisown' attribute */
23452 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23453 (void)thisown_descr;
23454
23455 public_interface = PyList_New(0);
23456 public_symbol = 0;
23457 (void)public_symbol;
23458
23459 PyDict_SetItemString(md, "__all__", public_interface);
23460 Py_DECREF(public_interface);
23461 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23462 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23463 for (i = 0; swig_const_table[i].name != 0; ++i)
23464 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23465#endif
23466
23468
23469
23470 import_array();
23471
23472 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23473 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23474 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23475 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23476 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23477 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23478 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23479 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23480 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23481 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23482 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23483 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23484 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23485 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23486 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23487 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23488 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23489 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23490 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23491 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23492 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23493 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23494 SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23495 SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23496 SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23497 SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23498 SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23499 SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23500 SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23501 SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23502 SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23503 SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23504 SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23505 SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23506 SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23507 SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23508 SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23509 SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23510 SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23511 SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23512 SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23513 SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23514 SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23515 SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23516 SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23517 SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23518 SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23519 SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23520 SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23521 SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23522 SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23523 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23524 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23525 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23526 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23527 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23528 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23529 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23530 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23531 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23532 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23533 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23534 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23535 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23536 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23537 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23538 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23539 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23540 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23541 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23542 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23543 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23544 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23545 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23546 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23547 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23548 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23549 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23550 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23551 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23552 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23553 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23554 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23555 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23556 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23557 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23558 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23559 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23560 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23561 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23562 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23563 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23564 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23565 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23566 SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23567 SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23568 SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23569 SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23570 SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23571 SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23572 SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23573 SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23574 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23575 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23576 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23577 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23578 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23579 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23580 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23581 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL0",SWIG_From_int((int)(16)));
23582 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL1",SWIG_From_int((int)(128)));
23583 SWIG_Python_SetConstant(d, "MIN_PLINT_RGB",SWIG_From_int((int)(0)));
23584 SWIG_Python_SetConstant(d, "MAX_PLINT_RGB",SWIG_From_int((int)(255)));
23585 SWIG_Python_SetConstant(d, "MIN_PLFLT_CMAP1",SWIG_From_double((double)(0.)));
23586 SWIG_Python_SetConstant(d, "MAX_PLFLT_CMAP1",SWIG_From_double((double)(1.)));
23587 SWIG_Python_SetConstant(d, "MIN_PLFLT_ALPHA",SWIG_From_double((double)(0.)));
23588 SWIG_Python_SetConstant(d, "MAX_PLFLT_ALPHA",SWIG_From_double((double)(1.)));
23589 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23590 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23591 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23592 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23593 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23594 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23595 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23596 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23597 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23598 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23599 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23600 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23601 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23602 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23603 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23604 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23605 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23606 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23607 SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23608 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23609 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23610 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23611 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23612 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23613 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23614 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23615 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23616 SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23617 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23618 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23619 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23620 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23621 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23622 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23623 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23624 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23625 SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23626 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23627 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23628 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23629 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23630 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23631 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23632 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23633 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23634 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23635 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23636 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23637 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23638 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23639 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23640 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23641 SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23642 SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23643 SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23644 SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23645 SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23646 SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23647 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23648 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23649 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23650 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23651 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23652 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23653 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23654 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23655 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23656 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23657#if PY_VERSION_HEX >= 0x03000000
23658 return m;
23659#else
23660 return;
23661#endif
23662}
23663
#define min(x, y)
Definition nnpi.c:87
#define max(x, y)
Definition nnpi.c:88
void plOptUsage(void)
Definition plargs.c:1304
void plClearOpts(void)
Definition plargs.c:830
void plResetOpts(void)
Definition plargs.c:843
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition plargs.c:1287
static int error
Definition plcont.c:61
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:941
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:874
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition plcont.c:858
void plsxwin(PLINT window_id)
Definition plcore.c:3978
static PLFLT value(double n1, double n2, double hue)
Definition plctrl.c:1219
void plMinMax2dGrid(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLFLT *fnmax, PLFLT *fnmin)
Definition plmem.c:141
PLINT plGetCursor(PLGraphicsIn *plg)
Definition plpage.c:244
#define plgfci
Definition plplot.h:735
#define plgstrm
Definition plplot.h:744
#define plpat
Definition plplot.h:779
#define plschr
Definition plplot.h:790
#define plfontld
Definition plplot.h:721
#define plpath
Definition plplot.h:761
#define plerry
Definition plplot.h:715
#define plsfam
Definition plplot.h:816
#define plsmaj
Definition plplot.h:826
#define plsmin
Definition plplot.h:829
#define pleop
Definition plplot.h:713
#define plimage
Definition plplot.h:753
#define plstransform
Definition plplot.h:840
#define plmap
Definition plplot.h:764
#define plfill
Definition plplot.h:717
#define plvpas
Definition plplot.h:859
#define plgdiplt
Definition plplot.h:732
#define plerrx
Definition plplot.h:714
#define plinit
Definition plplot.h:755
#define plscmap1l
Definition plplot.h:796
#define plsori
Definition plplot.h:830
#define plbox3
Definition plplot.h:698
#define plmapfill
Definition plplot.h:768
#define plcol1
Definition plplot.h:703
#define pltimefmt
Definition plplot.h:856
PLUINT PLUNICODE
Definition plplot.h:201
#define plmaptex
Definition plplot.h:767
#define plvect
Definition plplot.h:858
#define plgchr
Definition plplot.h:722
float PLFLT
Definition plplot.h:163
#define pllegend
Definition plplot.h:758
#define plsyax
Definition plplot.h:852
#define plgver
Definition plplot.h:745
#define plscolbg
Definition plplot.h:802
#define plpsty
Definition plplot.h:784
#define plgfont
Definition plplot.h:737
#define plenv
Definition plplot.h:711
#define pllightsource
Definition plplot.h:759
#define plsmema
Definition plplot.h:828
#define plpoin3
Definition plplot.h:781
#define plgspa
Definition plplot.h:743
#define plscol0
Definition plplot.h:800
#define plptex
Definition plplot.h:785
#define plrgbhls
Definition plplot.h:789
#define plbop
Definition plplot.h:696
#define plgdidev
Definition plplot.h:730
#define plpoin
Definition plplot.h:780
#define plptex3
Definition plplot.h:786
#define plstripd
Definition plplot.h:845
#define plhist
Definition plplot.h:751
#define plmapline
Definition plplot.h:765
#define plgfnam
Definition plplot.h:736
#define plgdiori
Definition plplot.h:731
#define plszax
Definition plplot.h:854
#define plsmem
Definition plplot.h:827
#define plstripa
Definition plplot.h:843
#define plgxax
Definition plplot.h:748
#define plgra
Definition plplot.h:740
#define plenv0
Definition plplot.h:712
#define plspal1
Definition plplot.h:833
#define plstring3
Definition plplot.h:842
#define plxormod
Definition plplot.h:865
#define plspause
Definition plplot.h:834
#define plgdev
Definition plplot.h:729
#define plgradient
Definition plplot.h:741
#define plspal0
Definition plplot.h:832
#define plcalc_world
Definition plplot.h:700
#define plwidth
Definition plplot.h:863
#define pllab
Definition plplot.h:757
#define plsurf3d
Definition plplot.h:847
#define plsurf3dl
Definition plplot.h:848
#define plvasp
Definition plplot.h:857
#define plscmap0n
Definition plplot.h:793
#define plmtex3
Definition plplot.h:774
#define plctime
Definition plplot.h:708
#define plclear
Definition plplot.h:701
#define plsvpa
Definition plplot.h:850
#define plw3d
Definition plplot.h:862
#define plot3dcl
Definition plplot.h:777
#define plscmap1n
Definition plplot.h:798
#define plgvpd
Definition plplot.h:746
#define plhlsrgb
Definition plplot.h:752
#define pl_setcontlabelformat
Definition plplot.h:690
#define plsdev
Definition plplot.h:806
#define plconfigtime
Definition plplot.h:705
#define plscolbga
Definition plplot.h:803
#define PL_UNUSED(x)
Definition plplot.h:138
#define plscmap1
Definition plplot.h:794
#define plsdiplz
Definition plplot.h:811
#define plparseopts
Definition plplot.h:778
#define plmapstring
Definition plplot.h:766
#define plot3d
Definition plplot.h:775
#define plsesc
Definition plplot.h:814
#define plarc
Definition plplot.h:693
#define plsetopt
Definition plplot.h:815
#define plgvpw
Definition plplot.h:747
#define pltext
Definition plplot.h:855
#define plstring
Definition plplot.h:841
#define plsdiori
Definition plplot.h:809
#define plcont
Definition plplot.h:706
#define plspage
Definition plplot.h:831
#define plaxes
Definition plplot.h:694
#define pllsty
Definition plplot.h:763
#define plslabelfunc
Definition plplot.h:825
#define plshades
Definition plplot.h:824
#define plglevel
Definition plplot.h:738
#define plscompression
Definition plplot.h:805
#define plfamadv
Definition plplot.h:716
#define plfont
Definition plplot.h:720
#define plscmap0a
Definition plplot.h:792
#define plgcol0a
Definition plplot.h:725
#define plscmap1_range
Definition plplot.h:799
#define plmeshc
Definition plplot.h:771
#define plshade
Definition plplot.h:820
#define plsym
Definition plplot.h:853
#define plscmap1a
Definition plplot.h:795
#define plscmap0
Definition plplot.h:791
#define plgriddata
Definition plplot.h:742
#define plstripc
Definition plplot.h:844
#define pl_setcontlabelparam
Definition plplot.h:691
#define plsvect
Definition plplot.h:849
#define plstyl
Definition plplot.h:846
#define plline
Definition plplot.h:760
#define pljoin
Definition plplot.h:756
#define plgzax
Definition plplot.h:750
#define plsstrm
Definition plplot.h:835
#define plscmap1la
Definition plplot.h:797
#define plssym
Definition plplot.h:837
#define plscolor
Definition plplot.h:804
#define plcol0
Definition plplot.h:702
#define plsdiplt
Definition plplot.h:810
#define plcolorbar
Definition plplot.h:704
#define plvsta
Definition plplot.h:861
#define plmeridians
Definition plplot.h:769
#define plot3dc
Definition plplot.h:776
#define plcpstrm
Definition plplot.h:707
#define plmkstrm
Definition plplot.h:772
#define plgcol0
Definition plplot.h:724
#define pladv
Definition plplot.h:692
#define plgcolbga
Definition plplot.h:727
#define plline3
Definition plplot.h:762
#define plprec
Definition plplot.h:783
#define plfill3
Definition plplot.h:718
#define plseed
Definition plplot.h:813
#define plgcompression
Definition plplot.h:728
#define plimagefr
Definition plplot.h:754
#define plsfont
Definition plplot.h:819
int PLINT
Definition plplot.h:181
#define plgfam
Definition plplot.h:734
#define plscol0a
Definition plplot.h:801
#define plend1
Definition plplot.h:710
#define plrandd
Definition plplot.h:787
#define plbin
Definition plplot.h:695
#define plsdidev
Definition plplot.h:807
#define plsfnam
Definition plplot.h:818
void * PLPointer
Definition plplot.h:209
#define plflush
Definition plplot.h:719
#define plwind
Definition plplot.h:864
#define plstar
Definition plplot.h:838
#define plmtex
Definition plplot.h:773
PLINT PLBOOL
Definition plplot.h:204
#define plsdimap
Definition plplot.h:808
#define plsfci
Definition plplot.h:817
#define plend
Definition plplot.h:709
#define plmesh
Definition plplot.h:770
#define plreplot
Definition plplot.h:788
#define plgcolbg
Definition plplot.h:726
#define plgcmap1_range
Definition plplot.h:723
#define plstart
Definition plplot.h:839
#define plsxax
Definition plplot.h:851
#define plbox
Definition plplot.h:697
#define plbtime
Definition plplot.h:699
#define plgyax
Definition plplot.h:749
#define plvpor
Definition plplot.h:860
#define plpoly3
Definition plplot.h:782
#define plgpage
Definition plplot.h:739
#define plssub
Definition plplot.h:836
SWIGINTERN PyObject * _wrap_plstransform(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *self, PyObject *args)
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *self, PyObject *args)
static swig_cast_info * swig_cast_initial[]
SWIGINTERN int swig_varlink_setattr(PyObject *o, char *n, PyObject *p)
SWIGINTERN PyObject * _wrap_plgra(PyObject *self, PyObject *args)
static int interpreter_counter
static PLcGrid2 tmpGrid2
SWIGINTERN PyObject * _wrap_plvpas(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *self, PyObject *args)
#define SWIG_MangledTypeQuery(name)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args)
static PLcGrid tmpGrid1
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *self, PyObject *args)
static PyObject * Swig_This_global
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
static swig_cast_info _swigc__p_PLcGrid2[]
SWIGINTERN PyObject * _wrap_plerrx(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *self, PyObject *args)
SWIGINTERN Py_ssize_t SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
#define SWIG_TypeQuery(name)
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *self, PyObject *args)
#define SWIG_POINTER_OWN
SWIGINTERN PyObject * _wrap_plfill3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args)
#define SWIG_SyntaxError
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *self, PyObject *args)
#define SWIG_POINTER_NEW
SWIGINTERN PyObject * _wrap_plgfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *self, PyObject *args)
#define SWIG_CheckState(r)
static swig_cast_info _swigc__p_f_double_double__int[]
void cleanup_mapform(void)
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_int[]
SWIGINTERN PyObject * _wrap_plschr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstart(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args)
#define SWIG_BUFFER_SIZE
#define SWIG_TypeError
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
pltr_func marshal_pltr(PyObject *input)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args)
static PLINT Alen
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args)
#define myArray_ContiguousFromObject
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plend(PyObject *self, PyObject *args)
#define SWIG_POINTER_IMPLICIT_CONV
static swig_cast_info _swigc__p_double[]
#define SWIGTYPE_p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *self, PyObject *args)
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plbin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *self, PyObject *args)
#define SWIG_PY_POINTER
struct swig_cast_info swig_cast_info
SWIGINTERN PyObject * _wrap_plpoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *self, PyObject *args)
#define SWIG_init
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
#define SWIG_PYTHON_THREAD_END_BLOCK
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *self, PyObject *args)
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *self, PyObject *args)
#define SWIG_RuntimeError
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
SWIGINTERN PyObject * _wrap_pladv(PyObject *self, PyObject *args)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *self, PyObject *args)
#define SWIGPY_CAPSULE_ATTR_NAME
SWIGINTERN PyObject * _wrap_plsfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmema(PyObject *self, PyObject *args)
struct swig_varlinkobject swig_varlinkobject
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *self, PyObject *args)
#define SWIG_NewClientData(obj)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *self, PyObject *args)
mapform_func marshal_mapform(PyObject *input)
#define PyObject_DEL
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGINTERN PyObject * _wrap_plline(PyObject *self, PyObject *args)
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *self, PyObject *args)
#define SWIGRUNTIME
SWIGINTERN PyObject * _wrap_plvasp(PyObject *self, PyObject *args)
#define SWIG_PY_BINARY
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *self, PyObject *args)
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *self, PyObject *args)
PyObject * python_f2eval
#define SWIG_RUNTIME_VERSION
SWIGINTERN PyObject * _wrap_plscolor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
SWIGINTERN PyObject * _wrap_plssym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *self, PyObject *args)
#define SWIG_POINTER_NOSHADOW
SWIGINTERN PyObject * _wrap_plwind(PyObject *self, PyObject *args)
#define SWIG_OLDOBJ
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
#define SWIG_ValueError
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGINTERN PyObject * _wrap_plend1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *self, PyObject *args)
#define t_output_helper
SWIGINTERN PyObject * _wrap_plsmin(PyObject *self, PyObject *args)
static PyMethodDef swigobject_methods[]
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *self, PyObject *args)
#define SWIG_AddCast(r)
void cleanup_PLcGrid1(void)
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
#define SWIG_IsNewObj(r)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *self, PyObject *args)
#define SWIG_InternalNewPointerObj(ptr, type, flags)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *self, PyObject *args)
#define NPY_PLFLT
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
#define SWIG_exception_fail(code, msg)
void cleanup_ct(void)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltr2(PyObject *self, PyObject *args)
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args)
#define SWIG_AttributeError
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args)
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args)
static swig_module_info swig_module
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *self, PyObject *args)
static PLINT Ylen
SWIGINTERN PyObject * _wrap_pltr1(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_double
SWIGINTERN PyObject * _wrap_plgdev(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_TypeErrorOccurred(PyObject *obj)
SWIGRUNTIME void SWIG_Python_DestroyModule(PyObject *obj)
#define SWIG_SetModule(clientdata, pointer)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *self, PyObject *args)
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
SWIGINTERN PyObject * swig_varlink_str(PyObject *o)
SWIGINTERN PyTypeObject * swig_varlink_type(void)
SWIGINTERN PyObject * _wrap_pllab(PyObject *self, PyObject *args)
#define SWIG_INIT_CLIENT_DATA_TYPE
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *self, PyObject *args)
#define SWIGUNUSEDPARM(p)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *self, PyObject *args)
PLPointer marshal_PLPointer(PyObject *input, int isimg)
#define SWIG_POINTER_RELEASE
SWIGINTERN PyObject * _wrap_plstring3(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define SWIG_as_voidptr(a)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
static swig_const_info swig_const_table[]
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plscol0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
static swig_type_info _swigt__p_p_char
#define SWIG_Python_CallFunctor(functor, obj)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
static swig_type_info _swigt__p_p_double
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *self, PyObject *args)
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
#define SWIG_POINTER_CLEAR
PyObject * python_label
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
#define SWIGTYPE_p_int
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
struct swig_const_info swig_const_info
SWIGINTERN PyObject * _wrap_plpsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plimage(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *self, PyObject *args)
static PyObject * Swig_Globals_global
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *self, PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *self, PyObject *args)
#define SWIG_newvarlink()
SWIGRUNTIME void SWIG_Python_RaiseOrModifyTypeError(const char *message)
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
SWIGINTERN const char * SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
PLINT(* defined_func)(PLFLT, PLFLT)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *self, PyObject *args)
void cleanup_pltr(void)
void cleanup_PLcGrid2(void)
static PyObject * Swig_TypeCache_global
SWIGINTERN PyObject * _wrap_plglevel(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_p_double[]
#define SWIGINTERN
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
SWIGINTERN PyObject * _wrap_plpath(PyObject *self, PyObject *args)
#define SWIG_From_double
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
struct swig_globalvar swig_globalvar
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
#define SWIGPY_CAPSULE_NAME
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
#define SWIG_ArgError(r)
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
PyObject * python_pltr
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
#define SWIG_NewPointerObj(ptr, type, flags)
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *self, PyObject *args)
ct_func marshal_ct(PyObject *input)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *self, PyObject *args)
#define SWIG_POINTER_NO_NULL
#define SWIG_Python_str_FromFormat
#define SWIG_InstallConstants(d, constants)
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *self, PyObject *args)
#define SWIG_IOError
static PyMethodDef SwigMethods[]
#define SWIG_NullReferenceError
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_pleop(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
#define SWIG_POINTER_DISOWN
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args)
#define SWIG_STATIC_POINTER(var)
struct swig_type_info swig_type_info
PyObject * python_mapform
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v))
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
static swig_type_info _swigt__p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plflush(PyObject *self, PyObject *args)
#define SWIG_IsTmpObj(r)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_f_double_double__int
SWIGINTERN PyObject * _wrap_plcont(PyObject *self, PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
SWIGINTERN PyObject * _wrap_plsori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plbop(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
#define SWIG_NEWOBJ
#define MY_BLOCK_THREADS
SWIGINTERN PyObject * _wrap_plgver(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *self, PyObject *args)
#define SWIG_TMPOBJ
SWIGINTERN PyObject * _wrap_pllsty(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
#define SWIG_DelNewMask(r)
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *self, PyObject *args)
#define SWIG_NewPackedObj(ptr, sz, type)
static swig_cast_info _swigc__p_PLcGrid[]
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *self, PyObject *args)
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
#define SWIG_GetModule(clientdata)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_unsigned_int[]
#define SWIG_fail
static swig_type_info _swigt__p_int
SWIGINTERN PyObject * PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *self, PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty)
SWIGRUNTIME void SWIG_PropagateClientData(void)
PyArrayObject * pltr_xg
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
#define NPY_PLINT
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
SWIGINTERN PyObject * _wrap_plsmem(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *self, PyObject *args)
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
#define SWIG_ERROR_RELEASE_NOT_OWNED
SWIGRUNTIME PyObject * SWIG_This(void)
SWIGINTERN PyObject * _wrap_plenv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_PLcGrid
#define SWIG_BUILTIN_TP_INIT
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
SWIGINTERN void swig_varlink_dealloc(PyObject *o)
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v)
static PLINT Xlen
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
SWIGINTERN PyObject * _wrap_plfont(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *self, PyObject *args)
PyArrayObject * pltr_yg
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args)
struct swig_module_info swig_module_info
PyObject * python_ct
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
#define SWIG_ERROR
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
#define SWIG_name
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *self, PyObject *args)
static swig_type_info * swig_type_initial[]
SWIGINTERN PyObject * _wrap_plerry(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *self, PyObject *args)
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
#define PySequence_Fast_GET_ITEM
SWIGINTERN PyObject * _wrap_plmap(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
SWIGINTERN PyObject * _wrap_plhist(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGINTERN PyObject * _wrap_pltr0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *self, PyObject *args)
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_getattr(PyObject *o, char *n)
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args)
#define PySequence_Size
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *self, PyObject *args)
#define SWIG_MemoryError
SWIGINTERN PyObject * _wrap_plfontld(PyObject *self, PyObject *args)
#define SWIG_SystemError
#define SWIG_DivisionByZero
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args)
#define SWIGTYPE_p_double
static swig_type_info _swigt__p_char
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
#define SWIG_OverflowError
#define SWIGEXPORT
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
#define SWIG_IsOK(r)
SWIGINTERN PyObject * _wrap_plstring(PyObject *self, PyObject *args)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
static PyObject * Swig_Capsule_global
static swig_type_info _swigt__p_PLcGrid2
SWIGINTERN PyObject * _wrap_plctime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *self, PyObject *args)
#define SWIG_IndexError
SWIGINTERN PyObject * _wrap_plspal0(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
static swig_type_info * swig_types[15]
SWIGRUNTIME PyObject * SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *self, PyObject *args)
#define SWIG_AddNewMask(r)
SWIGINTERN PyObject * SWIG_globals(void)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *self, PyObject *args)
#define SWIG_OK
SWIGINTERN PyObject * _wrap_plbox(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args)
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#define SWIGINTERNINLINE
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *self, PyObject *args)
enum callback_type pltr_type
SWIGINTERN PyObject * _wrap_plaxes(PyObject *self, PyObject *args)
#define Py_TYPE(op)
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
#define MY_UNBLOCK_THREADS
#define SWIGRUNTIMEINLINE
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
char string[PL_MAXKEY]
Definition plplot.h:440
PLINT nx
Definition plplot.h:521
PLFLT_NC_MATRIX xg
Definition plplot.h:520
PLINT ny
Definition plplot.h:521
PLFLT_NC_MATRIX yg
Definition plplot.h:520
PLFLT_NC_FE_POINTER xg
Definition plplot.h:508
PLFLT_NC_FE_POINTER yg
Definition plplot.h:508
PLINT nx
Definition plplot.h:509
PLINT ny
Definition plplot.h:509
PyObject_HEAD void * ptr
swig_type_info * ty
swig_type_info * ty
PyObject_HEAD void * pack
swig_type_info * type
struct swig_cast_info * prev
struct swig_cast_info * next
swig_converter_func converter
swig_type_info ** ptype
PyObject *(* get_attr)(void)
struct swig_globalvar * next
int(* set_attr)(PyObject *)
swig_type_info ** types
swig_cast_info ** cast_initial
swig_type_info ** type_initial
struct swig_module_info * next
swig_dycast_func dcast
struct swig_cast_info * cast
PyObject_HEAD swig_globalvar * vars
static char buf[200]
Definition tclAPI.c:873
static tclMatrixXtnsnDescr * tail
Definition tclMatrix.c:461
static const char * name
Definition tkMain.c:135