PLplot 5.15.0
plplotcPYTHON_wrap.c
Go to the documentation of this file.
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 4.0.2
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11
12#ifndef SWIGPYTHON
13#define SWIGPYTHON
14#endif
15
16#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
17
18/* -----------------------------------------------------------------------------
19 * This section contains generic SWIG labels for method/variable
20 * declarations/attributes, and other compiler dependent labels.
21 * ----------------------------------------------------------------------------- */
22
23/* template workaround for compilers that cannot correctly implement the C++ standard */
24#ifndef SWIGTEMPLATEDISAMBIGUATOR
25# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
26# define SWIGTEMPLATEDISAMBIGUATOR template
27# elif defined(__HP_aCC)
28/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
29/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
30# define SWIGTEMPLATEDISAMBIGUATOR template
31# else
32# define SWIGTEMPLATEDISAMBIGUATOR
33# endif
34#endif
35
36/* inline attribute */
37#ifndef SWIGINLINE
38# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
39# define SWIGINLINE inline
40# else
41# define SWIGINLINE
42# endif
43#endif
44
45/* attribute recognised by some compilers to avoid 'unused' warnings */
46#ifndef SWIGUNUSED
47# if defined(__GNUC__)
48# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
49# define SWIGUNUSED __attribute__ ((__unused__))
50# else
51# define SWIGUNUSED
52# endif
53# elif defined(__ICC)
54# define SWIGUNUSED __attribute__ ((__unused__))
55# else
56# define SWIGUNUSED
57# endif
58#endif
59
60#ifndef SWIG_MSC_UNSUPPRESS_4505
61# if defined(_MSC_VER)
62# pragma warning(disable : 4505) /* unreferenced local function has been removed */
63# endif
64#endif
65
66#ifndef SWIGUNUSEDPARM
67# ifdef __cplusplus
68# define SWIGUNUSEDPARM(p)
69# else
70# define SWIGUNUSEDPARM(p) p SWIGUNUSED
71# endif
72#endif
73
74/* internal SWIG method */
75#ifndef SWIGINTERN
76# define SWIGINTERN static SWIGUNUSED
77#endif
78
79/* internal inline SWIG method */
80#ifndef SWIGINTERNINLINE
81# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
82#endif
83
84/* exporting methods */
85#if defined(__GNUC__)
86# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
87# ifndef GCC_HASCLASSVISIBILITY
88# define GCC_HASCLASSVISIBILITY
89# endif
90# endif
91#endif
92
93#ifndef SWIGEXPORT
94# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
95# if defined(STATIC_LINKED)
96# define SWIGEXPORT
97# else
98# define SWIGEXPORT __declspec(dllexport)
99# endif
100# else
101# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
102# define SWIGEXPORT __attribute__ ((visibility("default")))
103# else
104# define SWIGEXPORT
105# endif
106# endif
107#endif
108
109/* calling conventions for Windows */
110#ifndef SWIGSTDCALL
111# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
112# define SWIGSTDCALL __stdcall
113# else
114# define SWIGSTDCALL
115# endif
116#endif
117
118/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
119#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
120# define _CRT_SECURE_NO_DEPRECATE
121#endif
122
123/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
124#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
125# define _SCL_SECURE_NO_DEPRECATE
126#endif
127
128/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
129#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
130# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
131#endif
132
133/* Intel's compiler complains if a variable which was never initialised is
134 * cast to void, which is a common idiom which we use to indicate that we
135 * are aware a variable isn't used. So we just silence that warning.
136 * See: https://github.com/swig/swig/issues/192 for more discussion.
137 */
138#ifdef __INTEL_COMPILER
139# pragma warning disable 592
140#endif
141
142
143#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
144/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
145# include <math.h>
146#endif
147
148#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
149/* Use debug wrappers with the Python release dll */
150# undef _DEBUG
151# include <Python.h>
152# define _DEBUG 1
153#else
154# include <Python.h>
155#endif
156
157/* -----------------------------------------------------------------------------
158 * swigrun.swg
159 *
160 * This file contains generic C API SWIG runtime support for pointer
161 * type checking.
162 * ----------------------------------------------------------------------------- */
163
164/* This should only be incremented when either the layout of swig_type_info changes,
165 or for whatever reason, the runtime changes incompatibly */
166#define SWIG_RUNTIME_VERSION "4"
167
168/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
169#ifdef SWIG_TYPE_TABLE
170# define SWIG_QUOTE_STRING(x) #x
171# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
172# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
173#else
174# define SWIG_TYPE_TABLE_NAME
175#endif
176
177/*
178 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
179 creating a static or dynamic library from the SWIG runtime code.
180 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
181
182 But only do this if strictly necessary, ie, if you have problems
183 with your compiler or suchlike.
184*/
185
186#ifndef SWIGRUNTIME
187# define SWIGRUNTIME SWIGINTERN
188#endif
189
190#ifndef SWIGRUNTIMEINLINE
191# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
192#endif
193
194/* Generic buffer size */
195#ifndef SWIG_BUFFER_SIZE
196# define SWIG_BUFFER_SIZE 1024
197#endif
198
199/* Flags for pointer conversions */
200#define SWIG_POINTER_DISOWN 0x1
201#define SWIG_CAST_NEW_MEMORY 0x2
202#define SWIG_POINTER_NO_NULL 0x4
203
204/* Flags for new pointer objects */
205#define SWIG_POINTER_OWN 0x1
206
207
208/*
209 Flags/methods for returning states.
210
211 The SWIG conversion methods, as ConvertPtr, return an integer
212 that tells if the conversion was successful or not. And if not,
213 an error code can be returned (see swigerrors.swg for the codes).
214
215 Use the following macros/flags to set or process the returning
216 states.
217
218 In old versions of SWIG, code such as the following was usually written:
219
220 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
221 // success code
222 } else {
223 //fail code
224 }
225
226 Now you can be more explicit:
227
228 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
229 if (SWIG_IsOK(res)) {
230 // success code
231 } else {
232 // fail code
233 }
234
235 which is the same really, but now you can also do
236
237 Type *ptr;
238 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
239 if (SWIG_IsOK(res)) {
240 // success code
241 if (SWIG_IsNewObj(res) {
242 ...
243 delete *ptr;
244 } else {
245 ...
246 }
247 } else {
248 // fail code
249 }
250
251 I.e., now SWIG_ConvertPtr can return new objects and you can
252 identify the case and take care of the deallocation. Of course that
253 also requires SWIG_ConvertPtr to return new result values, such as
254
255 int SWIG_ConvertPtr(obj, ptr,...) {
256 if (<obj is ok>) {
257 if (<need new object>) {
258 *ptr = <ptr to new allocated object>;
259 return SWIG_NEWOBJ;
260 } else {
261 *ptr = <ptr to old object>;
262 return SWIG_OLDOBJ;
263 }
264 } else {
265 return SWIG_BADOBJ;
266 }
267 }
268
269 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
270 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
271 SWIG errors code.
272
273 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
274 allows to return the 'cast rank', for example, if you have this
275
276 int food(double)
277 int fooi(int);
278
279 and you call
280
281 food(1) // cast rank '1' (1 -> 1.0)
282 fooi(1) // cast rank '0'
283
284 just use the SWIG_AddCast()/SWIG_CheckState()
285*/
286
287#define SWIG_OK (0)
288#define SWIG_ERROR (-1)
289#define SWIG_IsOK(r) (r >= 0)
290#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
291
292/* The CastRankLimit says how many bits are used for the cast rank */
293#define SWIG_CASTRANKLIMIT (1 << 8)
294/* The NewMask denotes the object was created (using new/malloc) */
295#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
296/* The TmpMask is for in/out typemaps that use temporal objects */
297#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
298/* Simple returning values */
299#define SWIG_BADOBJ (SWIG_ERROR)
300#define SWIG_OLDOBJ (SWIG_OK)
301#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
302#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
303/* Check, add and del mask methods */
304#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
305#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
306#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
307#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
308#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
309#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
310
311/* Cast-Rank Mode */
312#if defined(SWIG_CASTRANK_MODE)
313# ifndef SWIG_TypeRank
314# define SWIG_TypeRank unsigned long
315# endif
316# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
317# define SWIG_MAXCASTRANK (2)
318# endif
319# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
320# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
322 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
323}
325 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
326}
327#else /* no cast-rank mode */
328# define SWIG_AddCast(r) (r)
329# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
330#endif
331
332
333#include <string.h>
334
335#ifdef __cplusplus
336extern "C" {
337#endif
338
339typedef void *(*swig_converter_func)(void *, int *);
340typedef struct swig_type_info *(*swig_dycast_func)(void **);
341
342/* Structure to store information on one type */
343typedef struct swig_type_info {
344 const char *name; /* mangled name of this type */
345 const char *str; /* human readable name of this type */
346 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
347 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
348 void *clientdata; /* language specific type data */
349 int owndata; /* flag if the structure owns the clientdata */
351
352/* Structure to store a type and conversion function used for casting */
353typedef struct swig_cast_info {
354 swig_type_info *type; /* pointer to type that is equivalent to this type */
355 swig_converter_func converter; /* function to cast the void pointers */
356 struct swig_cast_info *next; /* pointer to next cast in linked list */
357 struct swig_cast_info *prev; /* pointer to the previous cast */
359
360/* Structure used to store module information
361 * Each module generates one structure like this, and the runtime collects
362 * all of these structures and stores them in a circularly linked list.*/
363typedef struct swig_module_info {
364 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
365 size_t size; /* Number of types in this module */
366 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
367 swig_type_info **type_initial; /* Array of initially generated type structures */
368 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
369 void *clientdata; /* Language specific module data */
371
372/*
373 Compare two type names skipping the space characters, therefore
374 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
375
376 Return 0 when the two name types are equivalent, as in
377 strncmp, but skipping ' '.
378*/
379SWIGRUNTIME int
380SWIG_TypeNameComp(const char *f1, const char *l1,
381 const char *f2, const char *l2) {
382 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
383 while ((*f1 == ' ') && (f1 != l1)) ++f1;
384 while ((*f2 == ' ') && (f2 != l2)) ++f2;
385 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
386 }
387 return (int)((l1 - f1) - (l2 - f2));
388}
389
390/*
391 Check type equivalence in a name list like <name1>|<name2>|...
392 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
393*/
394SWIGRUNTIME int
395SWIG_TypeCmp(const char *nb, const char *tb) {
396 int equiv = 1;
397 const char* te = tb + strlen(tb);
398 const char* ne = nb;
399 while (equiv != 0 && *ne) {
400 for (nb = ne; *ne; ++ne) {
401 if (*ne == '|') break;
402 }
403 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
404 if (*ne) ++ne;
405 }
406 return equiv;
407}
408
409/*
410 Check type equivalence in a name list like <name1>|<name2>|...
411 Return 0 if not equal, 1 if equal
412*/
413SWIGRUNTIME int
414SWIG_TypeEquiv(const char *nb, const char *tb) {
415 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
416}
417
418/*
419 Check the typename
420*/
422SWIG_TypeCheck(const char *c, swig_type_info *ty) {
423 if (ty) {
424 swig_cast_info *iter = ty->cast;
425 while (iter) {
426 if (strcmp(iter->type->name, c) == 0) {
427 if (iter == ty->cast)
428 return iter;
429 /* Move iter to the top of the linked list */
430 iter->prev->next = iter->next;
431 if (iter->next)
432 iter->next->prev = iter->prev;
433 iter->next = ty->cast;
434 iter->prev = 0;
435 if (ty->cast) ty->cast->prev = iter;
436 ty->cast = iter;
437 return iter;
438 }
439 iter = iter->next;
440 }
441 }
442 return 0;
443}
444
445/*
446 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
447*/
450 if (ty) {
451 swig_cast_info *iter = ty->cast;
452 while (iter) {
453 if (iter->type == from) {
454 if (iter == ty->cast)
455 return iter;
456 /* Move iter to the top of the linked list */
457 iter->prev->next = iter->next;
458 if (iter->next)
459 iter->next->prev = iter->prev;
460 iter->next = ty->cast;
461 iter->prev = 0;
462 if (ty->cast) ty->cast->prev = iter;
463 ty->cast = iter;
464 return iter;
465 }
466 iter = iter->next;
467 }
468 }
469 return 0;
470}
471
472/*
473 Cast a pointer up an inheritance hierarchy
474*/
476SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
477 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
478}
479
480/*
481 Dynamic pointer casting. Down an inheritance hierarchy
482*/
485 swig_type_info *lastty = ty;
486 if (!ty || !ty->dcast) return ty;
487 while (ty && (ty->dcast)) {
488 ty = (*ty->dcast)(ptr);
489 if (ty) lastty = ty;
490 }
491 return lastty;
492}
493
494/*
495 Return the name associated with this type
496*/
497SWIGRUNTIMEINLINE const char *
499 return ty->name;
500}
501
502/*
503 Return the pretty name associated with this type,
504 that is an unmangled type name in a form presentable to the user.
505*/
506SWIGRUNTIME const char *
508 /* The "str" field contains the equivalent pretty names of the
509 type, separated by vertical-bar characters. We choose
510 to print the last name, as it is often (?) the most
511 specific. */
512 if (!type) return NULL;
513 if (type->str != NULL) {
514 const char *last_name = type->str;
515 const char *s;
516 for (s = type->str; *s; s++)
517 if (*s == '|') last_name = s+1;
518 return last_name;
519 }
520 else
521 return type->name;
522}
523
524/*
525 Set the clientdata field for a type
526*/
527SWIGRUNTIME void
529 swig_cast_info *cast = ti->cast;
530 /* if (ti->clientdata == clientdata) return; */
532
533 while (cast) {
534 if (!cast->converter) {
535 swig_type_info *tc = cast->type;
536 if (!tc->clientdata) {
538 }
539 }
540 cast = cast->next;
541 }
542}
543SWIGRUNTIME void
546 ti->owndata = 1;
547}
548
549/*
550 Search for a swig_type_info structure only by mangled name
551 Search is a O(log #types)
552
553 We start searching at module start, and finish searching when start == end.
554 Note: if start == end at the beginning of the function, we go all the way around
555 the circular list.
556*/
559 swig_module_info *end,
560 const char *name) {
561 swig_module_info *iter = start;
562 do {
563 if (iter->size) {
564 size_t l = 0;
565 size_t r = iter->size - 1;
566 do {
567 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
568 size_t i = (l + r) >> 1;
569 const char *iname = iter->types[i]->name;
570 if (iname) {
571 int compare = strcmp(name, iname);
572 if (compare == 0) {
573 return iter->types[i];
574 } else if (compare < 0) {
575 if (i) {
576 r = i - 1;
577 } else {
578 break;
579 }
580 } else if (compare > 0) {
581 l = i + 1;
582 }
583 } else {
584 break; /* should never happen */
585 }
586 } while (l <= r);
587 }
588 iter = iter->next;
589 } while (iter != end);
590 return 0;
591}
592
593/*
594 Search for a swig_type_info structure for either a mangled name or a human readable name.
595 It first searches the mangled names of the types, which is a O(log #types)
596 If a type is not found it then searches the human readable names, which is O(#types).
597
598 We start searching at module start, and finish searching when start == end.
599 Note: if start == end at the beginning of the function, we go all the way around
600 the circular list.
601*/
604 swig_module_info *end,
605 const char *name) {
606 /* STEP 1: Search the name field using binary search */
608 if (ret) {
609 return ret;
610 } else {
611 /* STEP 2: If the type hasn't been found, do a complete search
612 of the str field (the human readable name) */
613 swig_module_info *iter = start;
614 do {
615 size_t i = 0;
616 for (; i < iter->size; ++i) {
617 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
618 return iter->types[i];
619 }
620 iter = iter->next;
621 } while (iter != end);
622 }
623
624 /* neither found a match */
625 return 0;
626}
627
628/*
629 Pack binary data into a string
630*/
631SWIGRUNTIME char *
632SWIG_PackData(char *c, void *ptr, size_t sz) {
633 static const char hex[17] = "0123456789abcdef";
634 const unsigned char *u = (unsigned char *) ptr;
635 const unsigned char *eu = u + sz;
636 for (; u != eu; ++u) {
637 unsigned char uu = *u;
638 *(c++) = hex[(uu & 0xf0) >> 4];
639 *(c++) = hex[uu & 0xf];
640 }
641 return c;
642}
643
644/*
645 Unpack binary data from a string
646*/
647SWIGRUNTIME const char *
648SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
649 unsigned char *u = (unsigned char *) ptr;
650 const unsigned char *eu = u + sz;
651 for (; u != eu; ++u) {
652 char d = *(c++);
653 unsigned char uu;
654 if ((d >= '0') && (d <= '9'))
655 uu = (unsigned char)((d - '0') << 4);
656 else if ((d >= 'a') && (d <= 'f'))
657 uu = (unsigned char)((d - ('a'-10)) << 4);
658 else
659 return (char *) 0;
660 d = *(c++);
661 if ((d >= '0') && (d <= '9'))
662 uu |= (unsigned char)(d - '0');
663 else if ((d >= 'a') && (d <= 'f'))
664 uu |= (unsigned char)(d - ('a'-10));
665 else
666 return (char *) 0;
667 *u = uu;
668 }
669 return c;
670}
671
672/*
673 Pack 'void *' into a string buffer.
674*/
675SWIGRUNTIME char *
676SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
677 char *r = buff;
678 if ((2*sizeof(void *) + 2) > bsz) return 0;
679 *(r++) = '_';
680 r = SWIG_PackData(r,&ptr,sizeof(void *));
681 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
682 strcpy(r,name);
683 return buff;
684}
685
686SWIGRUNTIME const char *
687SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
688 if (*c != '_') {
689 if (strcmp(c,"NULL") == 0) {
690 *ptr = (void *) 0;
691 return name;
692 } else {
693 return 0;
694 }
695 }
696 return SWIG_UnpackData(++c,ptr,sizeof(void *));
697}
698
699SWIGRUNTIME char *
700SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
701 char *r = buff;
702 size_t lname = (name ? strlen(name) : 0);
703 if ((2*sz + 2 + lname) > bsz) return 0;
704 *(r++) = '_';
705 r = SWIG_PackData(r,ptr,sz);
706 if (lname) {
707 strncpy(r,name,lname+1);
708 } else {
709 *r = 0;
710 }
711 return buff;
712}
713
714SWIGRUNTIME const char *
715SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
716 if (*c != '_') {
717 if (strcmp(c,"NULL") == 0) {
718 memset(ptr,0,sz);
719 return name;
720 } else {
721 return 0;
722 }
723 }
724 return SWIG_UnpackData(++c,ptr,sz);
725}
726
727#ifdef __cplusplus
728}
729#endif
730
731/* Errors in SWIG */
732#define SWIG_UnknownError -1
733#define SWIG_IOError -2
734#define SWIG_RuntimeError -3
735#define SWIG_IndexError -4
736#define SWIG_TypeError -5
737#define SWIG_DivisionByZero -6
738#define SWIG_OverflowError -7
739#define SWIG_SyntaxError -8
740#define SWIG_ValueError -9
741#define SWIG_SystemError -10
742#define SWIG_AttributeError -11
743#define SWIG_MemoryError -12
744#define SWIG_NullReferenceError -13
745
746
747
748/* Compatibility macros for Python 3 */
749#if PY_VERSION_HEX >= 0x03000000
750
751#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
752#define PyInt_Check(x) PyLong_Check(x)
753#define PyInt_AsLong(x) PyLong_AsLong(x)
754#define PyInt_FromLong(x) PyLong_FromLong(x)
755#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
756#define PyString_Check(name) PyBytes_Check(name)
757#define PyString_FromString(x) PyUnicode_FromString(x)
758#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
759#define PyString_AsString(str) PyBytes_AsString(str)
760#define PyString_Size(str) PyBytes_Size(str)
761#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
762#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
763#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
764#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
765
766#endif
767
768#ifndef Py_TYPE
769# define Py_TYPE(op) ((op)->ob_type)
770#endif
771
772/* SWIG APIs for compatibility of both Python 2 & 3 */
773
774#if PY_VERSION_HEX >= 0x03000000
775# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
776#else
777# define SWIG_Python_str_FromFormat PyString_FromFormat
778#endif
779
780
781/* Warning: This function will allocate a new string in Python 3,
782 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
783 */
784SWIGINTERN char*
786{
787#if PY_VERSION_HEX >= 0x03030000
788 return (char *)PyUnicode_AsUTF8(str);
789#elif PY_VERSION_HEX >= 0x03000000
790 char *newstr = 0;
791 str = PyUnicode_AsUTF8String(str);
792 if (str) {
793 char *cstr;
794 Py_ssize_t len;
795 if (PyBytes_AsStringAndSize(str, &cstr, &len) != -1) {
796 newstr = (char *) malloc(len+1);
797 if (newstr)
798 memcpy(newstr, cstr, len+1);
799 }
800 Py_XDECREF(str);
801 }
802 return newstr;
803#else
804 return PyString_AsString(str);
805#endif
806}
807
808#if PY_VERSION_HEX >= 0x03030000 || PY_VERSION_HEX < 0x03000000
809# define SWIG_Python_str_DelForPy3(x)
810#else
811# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
812#endif
813
814
815SWIGINTERN PyObject*
817{
818#if PY_VERSION_HEX >= 0x03000000
819 return PyUnicode_FromString(c);
820#else
821 return PyString_FromString(c);
822#endif
823}
824
825#ifndef PyObject_DEL
826# define PyObject_DEL PyObject_Del
827#endif
828
829// SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user
830// interface files check for it.
831# define SWIGPY_USE_CAPSULE
832# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
833
834#if PY_VERSION_HEX < 0x03020000
835#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
836#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
837#define Py_hash_t long
838#endif
839
840/* -----------------------------------------------------------------------------
841 * error manipulation
842 * ----------------------------------------------------------------------------- */
843
844SWIGRUNTIME PyObject*
846 PyObject* type = 0;
847 switch(code) {
848 case SWIG_MemoryError:
849 type = PyExc_MemoryError;
850 break;
851 case SWIG_IOError:
852 type = PyExc_IOError;
853 break;
855 type = PyExc_RuntimeError;
856 break;
857 case SWIG_IndexError:
858 type = PyExc_IndexError;
859 break;
860 case SWIG_TypeError:
861 type = PyExc_TypeError;
862 break;
864 type = PyExc_ZeroDivisionError;
865 break;
867 type = PyExc_OverflowError;
868 break;
869 case SWIG_SyntaxError:
870 type = PyExc_SyntaxError;
871 break;
872 case SWIG_ValueError:
873 type = PyExc_ValueError;
874 break;
875 case SWIG_SystemError:
876 type = PyExc_SystemError;
877 break;
879 type = PyExc_AttributeError;
880 break;
881 default:
882 type = PyExc_RuntimeError;
883 }
884 return type;
885}
886
887
888SWIGRUNTIME void
889SWIG_Python_AddErrorMsg(const char* mesg)
890{
891 PyObject *type = 0;
892 PyObject *value = 0;
893 PyObject *traceback = 0;
894
895 if (PyErr_Occurred())
896 PyErr_Fetch(&type, &value, &traceback);
897 if (value) {
898 PyObject *old_str = PyObject_Str(value);
899 const char *tmp = SWIG_Python_str_AsChar(old_str);
900 PyErr_Clear();
901 Py_XINCREF(type);
902 if (tmp)
903 PyErr_Format(type, "%s %s", tmp, mesg);
904 else
905 PyErr_Format(type, "%s", mesg);
907 Py_DECREF(old_str);
908 Py_DECREF(value);
909 } else {
910 PyErr_SetString(PyExc_RuntimeError, mesg);
911 }
912}
913
914SWIGRUNTIME int
916{
917 PyObject *error;
918 if (obj)
919 return 0;
920 error = PyErr_Occurred();
921 return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
922}
923
924SWIGRUNTIME void
926{
928 /* Use existing TypeError to preserve stacktrace and enhance with given message */
929 PyObject *newvalue;
930 PyObject *type = NULL, *value = NULL, *traceback = NULL;
931 PyErr_Fetch(&type, &value, &traceback);
932#if PY_VERSION_HEX >= 0x03000000
933 newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
934#else
935 newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
936#endif
937 Py_XDECREF(value);
938 PyErr_Restore(type, newvalue, traceback);
939 } else {
940 /* Raise TypeError using given message */
941 PyErr_SetString(PyExc_TypeError, message);
942 }
943}
944
945#if defined(SWIG_PYTHON_NO_THREADS)
946# if defined(SWIG_PYTHON_THREADS)
947# undef SWIG_PYTHON_THREADS
948# endif
949#endif
950#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
951# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
952# define SWIG_PYTHON_USE_GIL
953# endif
954# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
955# ifndef SWIG_PYTHON_INITIALIZE_THREADS
956# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
957# endif
958# ifdef __cplusplus /* C++ code */
959 class SWIG_Python_Thread_Block {
960 bool status;
961 PyGILState_STATE state;
962 public:
963 void end() { if (status) { PyGILState_Release(state); status = false;} }
964 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
965 ~SWIG_Python_Thread_Block() { end(); }
966 };
967 class SWIG_Python_Thread_Allow {
968 bool status;
969 PyThreadState *save;
970 public:
971 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
972 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
973 ~SWIG_Python_Thread_Allow() { end(); }
974 };
975# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
976# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
977# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
978# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
979# else /* C code */
980# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
981# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
982# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
983# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
984# endif
985# else /* Old thread way, not implemented, user must provide it */
986# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
987# define SWIG_PYTHON_INITIALIZE_THREADS
988# endif
989# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
990# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
991# endif
992# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
993# define SWIG_PYTHON_THREAD_END_BLOCK
994# endif
995# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
996# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
997# endif
998# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
999# define SWIG_PYTHON_THREAD_END_ALLOW
1000# endif
1001# endif
1002#else /* No thread support */
1003# define SWIG_PYTHON_INITIALIZE_THREADS
1004# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1005# define SWIG_PYTHON_THREAD_END_BLOCK
1006# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1007# define SWIG_PYTHON_THREAD_END_ALLOW
1008#endif
1009
1010/* -----------------------------------------------------------------------------
1011 * Python API portion that goes into the runtime
1012 * ----------------------------------------------------------------------------- */
1013
1014#ifdef __cplusplus
1015extern "C" {
1016#endif
1017
1018/* -----------------------------------------------------------------------------
1019 * Constant declarations
1020 * ----------------------------------------------------------------------------- */
1021
1022/* Constant Types */
1023#define SWIG_PY_POINTER 4
1024#define SWIG_PY_BINARY 5
1025
1026/* Constant information structure */
1027typedef struct swig_const_info {
1028 int type;
1029 const char *name;
1031 double dvalue;
1032 void *pvalue;
1035
1036#ifdef __cplusplus
1037}
1038#endif
1039
1040
1041/* -----------------------------------------------------------------------------
1042 * pyrun.swg
1043 *
1044 * This file contains the runtime support for Python modules
1045 * and includes code for managing global variables and pointer
1046 * type checking.
1047 *
1048 * ----------------------------------------------------------------------------- */
1049
1050#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
1051# error "This version of SWIG only supports Python >= 2.7"
1052#endif
1053
1054#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000
1055# error "This version of SWIG only supports Python 3 >= 3.2"
1056#endif
1057
1058/* Common SWIG API */
1059
1060/* for raw pointers */
1061#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1062#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1063#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1064
1065#ifdef SWIGPYTHON_BUILTIN
1066#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1067#else
1068#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1069#endif
1070
1071#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1072
1073#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1074#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1075#define swig_owntype int
1076
1077/* for raw packed data */
1078#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1079#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1080
1081/* for class or struct pointers */
1082#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1083#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1084
1085/* for C or C++ function pointers */
1086#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1087#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1088
1089/* for C++ member pointers, ie, member methods */
1090#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1091#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1092
1093
1094/* Runtime API */
1095
1096#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1097#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1098#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1099
1100#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1101#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1102#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1103#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1104#define SWIG_fail goto fail
1105
1106
1107/* Runtime API implementation */
1108
1109/* Error manipulation */
1110
1111SWIGINTERN void
1112SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1114 PyErr_SetObject(errtype, obj);
1115 Py_DECREF(obj);
1117}
1118
1119SWIGINTERN void
1120SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1122 PyErr_SetString(errtype, msg);
1124}
1125
1126#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1127
1128/* Set a constant value */
1129
1130#if defined(SWIGPYTHON_BUILTIN)
1131
1132SWIGINTERN void
1133SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1134 PyObject *s = PyString_InternFromString(key);
1135 PyList_Append(seq, s);
1136 Py_DECREF(s);
1137}
1138
1139SWIGINTERN void
1140SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1141 PyDict_SetItemString(d, name, obj);
1142 Py_DECREF(obj);
1143 if (public_interface)
1144 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1145}
1146
1147#else
1148
1149SWIGINTERN void
1150SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1151 PyDict_SetItemString(d, name, obj);
1152 Py_DECREF(obj);
1153}
1154
1155#endif
1156
1157/* Append a value to the result obj */
1158
1159SWIGINTERN PyObject*
1160SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1161 if (!result) {
1162 result = obj;
1163 } else if (result == Py_None) {
1164 Py_DECREF(result);
1165 result = obj;
1166 } else {
1167 if (!PyList_Check(result)) {
1168 PyObject *o2 = result;
1169 result = PyList_New(1);
1170 PyList_SetItem(result, 0, o2);
1171 }
1172 PyList_Append(result,obj);
1173 Py_DECREF(obj);
1174 }
1175 return result;
1176}
1177
1178/* Unpack the argument tuple */
1179
1180SWIGINTERN Py_ssize_t
1181SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1182{
1183 if (!args) {
1184 if (!min && !max) {
1185 return 1;
1186 } else {
1187 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1188 name, (min == max ? "" : "at least "), (int)min);
1189 return 0;
1190 }
1191 }
1192 if (!PyTuple_Check(args)) {
1193 if (min <= 1 && max >= 1) {
1194 Py_ssize_t i;
1195 objs[0] = args;
1196 for (i = 1; i < max; ++i) {
1197 objs[i] = 0;
1198 }
1199 return 2;
1200 }
1201 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1202 return 0;
1203 } else {
1204 Py_ssize_t l = PyTuple_GET_SIZE(args);
1205 if (l < min) {
1206 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1207 name, (min == max ? "" : "at least "), (int)min, (int)l);
1208 return 0;
1209 } else if (l > max) {
1210 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1211 name, (min == max ? "" : "at most "), (int)max, (int)l);
1212 return 0;
1213 } else {
1214 Py_ssize_t i;
1215 for (i = 0; i < l; ++i) {
1216 objs[i] = PyTuple_GET_ITEM(args, i);
1217 }
1218 for (; l < max; ++l) {
1219 objs[l] = 0;
1220 }
1221 return i + 1;
1222 }
1223 }
1224}
1225
1226SWIGINTERN int
1227SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
1228 int no_kwargs = 1;
1229 if (kwargs) {
1230 assert(PyDict_Check(kwargs));
1231 if (PyDict_Size(kwargs) > 0) {
1232 PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
1233 no_kwargs = 0;
1234 }
1235 }
1236 return no_kwargs;
1237}
1238
1239/* A functor is a function object with one single object argument */
1240#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1241
1242/*
1243 Helper for static pointer initialization for both C and C++ code, for example
1244 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1245*/
1246#ifdef __cplusplus
1247#define SWIG_STATIC_POINTER(var) var
1248#else
1249#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1250#endif
1251
1252/* -----------------------------------------------------------------------------
1253 * Pointer declarations
1254 * ----------------------------------------------------------------------------- */
1255
1256/* Flags for new pointer objects */
1257#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1258#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1259
1260#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1261
1262#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1263#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1264
1265#ifdef __cplusplus
1266extern "C" {
1267#endif
1268
1269/* The python void return value */
1270
1271SWIGRUNTIMEINLINE PyObject *
1273{
1274 PyObject *none = Py_None;
1275 Py_INCREF(none);
1276 return none;
1277}
1278
1279/* SwigPyClientData */
1280
1281typedef struct {
1282 PyObject *klass;
1283 PyObject *newraw;
1284 PyObject *newargs;
1285 PyObject *destroy;
1288 PyTypeObject *pytype;
1290
1293{
1295 int fail = data ? data->implicitconv : 0;
1296 if (fail)
1297 PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
1298 return fail;
1299}
1300
1301SWIGRUNTIMEINLINE PyObject *
1303 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1304 PyObject *klass = data ? data->klass : 0;
1305 return (klass ? klass : PyExc_RuntimeError);
1306}
1307
1308
1311{
1312 if (!obj) {
1313 return 0;
1314 } else {
1315 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1316 /* the klass element */
1317 data->klass = obj;
1318 Py_INCREF(data->klass);
1319 /* the newraw method and newargs arguments used to create a new raw instance */
1320 if (PyClass_Check(obj)) {
1321 data->newraw = 0;
1322 data->newargs = obj;
1323 Py_INCREF(obj);
1324 } else {
1325 data->newraw = PyObject_GetAttrString(data->klass, "__new__");
1326 if (data->newraw) {
1327 Py_INCREF(data->newraw);
1328 data->newargs = PyTuple_New(1);
1329 PyTuple_SetItem(data->newargs, 0, obj);
1330 } else {
1331 data->newargs = obj;
1332 }
1333 Py_INCREF(data->newargs);
1334 }
1335 /* the destroy method, aka as the C++ delete method */
1336 data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1337 if (PyErr_Occurred()) {
1338 PyErr_Clear();
1339 data->destroy = 0;
1340 }
1341 if (data->destroy) {
1342 int flags;
1343 Py_INCREF(data->destroy);
1344 flags = PyCFunction_GET_FLAGS(data->destroy);
1345 data->delargs = !(flags & (METH_O));
1346 } else {
1347 data->delargs = 0;
1348 }
1349 data->implicitconv = 0;
1350 data->pytype = 0;
1351 return data;
1352 }
1353}
1354
1355SWIGRUNTIME void
1357 Py_XDECREF(data->newraw);
1358 Py_XDECREF(data->newargs);
1359 Py_XDECREF(data->destroy);
1360}
1361
1362/* =============== SwigPyObject =====================*/
1363
1364typedef struct {
1365 PyObject_HEAD
1366 void *ptr;
1368 int own;
1369 PyObject *next;
1370#ifdef SWIGPYTHON_BUILTIN
1371 PyObject *dict;
1372#endif
1373} SwigPyObject;
1374
1375
1376#ifdef SWIGPYTHON_BUILTIN
1377
1378SWIGRUNTIME PyObject *
1379SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1380{
1381 SwigPyObject *sobj = (SwigPyObject *)v;
1382
1383 if (!sobj->dict)
1384 sobj->dict = PyDict_New();
1385
1386 Py_INCREF(sobj->dict);
1387 return sobj->dict;
1388}
1389
1390#endif
1391
1392SWIGRUNTIME PyObject *
1394{
1395 return PyLong_FromVoidPtr(v->ptr);
1396}
1397
1398SWIGRUNTIME PyObject *
1400{
1401 PyObject *res = NULL;
1402 PyObject *args = PyTuple_New(1);
1403 if (args) {
1404 if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1405 PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1406 if (ofmt) {
1407#if PY_VERSION_HEX >= 0x03000000
1408 res = PyUnicode_Format(ofmt,args);
1409#else
1410 res = PyString_Format(ofmt,args);
1411#endif
1412 Py_DECREF(ofmt);
1413 }
1414 Py_DECREF(args);
1415 }
1416 }
1417 return res;
1418}
1419
1420SWIGRUNTIME PyObject *
1422{
1423 return SwigPyObject_format("%o",v);
1424}
1425
1426SWIGRUNTIME PyObject *
1428{
1429 return SwigPyObject_format("%x",v);
1430}
1431
1432SWIGRUNTIME PyObject *
1434{
1435 const char *name = SWIG_TypePrettyName(v->ty);
1436 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1437 if (v->next) {
1438 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1439# if PY_VERSION_HEX >= 0x03000000
1440 PyObject *joined = PyUnicode_Concat(repr, nrep);
1441 Py_DecRef(repr);
1442 Py_DecRef(nrep);
1443 repr = joined;
1444# else
1445 PyString_ConcatAndDel(&repr,nrep);
1446# endif
1447 }
1448 return repr;
1449}
1450
1451/* We need a version taking two PyObject* parameters so it's a valid
1452 * PyCFunction to use in swigobject_methods[]. */
1453SWIGRUNTIME PyObject *
1454SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1455{
1456 return SwigPyObject_repr((SwigPyObject*)v);
1457}
1458
1459SWIGRUNTIME int
1461{
1462 void *i = v->ptr;
1463 void *j = w->ptr;
1464 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1465}
1466
1467/* Added for Python 3.x, would it also be useful for Python 2.x? */
1468SWIGRUNTIME PyObject*
1470{
1471 PyObject* res;
1472 if( op != Py_EQ && op != Py_NE ) {
1473 Py_INCREF(Py_NotImplemented);
1474 return Py_NotImplemented;
1475 }
1476 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1477 return res;
1478}
1479
1480
1481SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1482
1483#ifdef SWIGPYTHON_BUILTIN
1484static swig_type_info *SwigPyObject_stype = 0;
1485SWIGRUNTIME PyTypeObject*
1486SwigPyObject_type(void) {
1487 SwigPyClientData *cd;
1488 assert(SwigPyObject_stype);
1489 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1490 assert(cd);
1491 assert(cd->pytype);
1492 return cd->pytype;
1493}
1494#else
1495SWIGRUNTIME PyTypeObject*
1497 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1498 return type;
1499}
1500#endif
1501
1503SwigPyObject_Check(PyObject *op) {
1504#ifdef SWIGPYTHON_BUILTIN
1505 PyTypeObject *target_tp = SwigPyObject_type();
1506 if (PyType_IsSubtype(op->ob_type, target_tp))
1507 return 1;
1508 return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1509#else
1510 return (Py_TYPE(op) == SwigPyObject_type())
1511 || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1512#endif
1513}
1514
1515SWIGRUNTIME PyObject *
1516SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1517
1518SWIGRUNTIME void
1520{
1521 SwigPyObject *sobj = (SwigPyObject *) v;
1522 PyObject *next = sobj->next;
1523 if (sobj->own == SWIG_POINTER_OWN) {
1524 swig_type_info *ty = sobj->ty;
1525 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1526 PyObject *destroy = data ? data->destroy : 0;
1527 if (destroy) {
1528 /* destroy is always a VARARGS method */
1529 PyObject *res;
1530
1531 /* PyObject_CallFunction() has the potential to silently drop
1532 the active exception. In cases of unnamed temporary
1533 variable or where we just finished iterating over a generator
1534 StopIteration will be active right now, and this needs to
1535 remain true upon return from SwigPyObject_dealloc. So save
1536 and restore. */
1537
1538 PyObject *type = NULL, *value = NULL, *traceback = NULL;
1539 PyErr_Fetch(&type, &value, &traceback);
1540
1541 if (data->delargs) {
1542 /* we need to create a temporary object to carry the destroy operation */
1543 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1544 res = SWIG_Python_CallFunctor(destroy, tmp);
1545 Py_DECREF(tmp);
1546 } else {
1547 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1548 PyObject *mself = PyCFunction_GET_SELF(destroy);
1549 res = ((*meth)(mself, v));
1550 }
1551 if (!res)
1552 PyErr_WriteUnraisable(destroy);
1553
1554 PyErr_Restore(type, value, traceback);
1555
1556 Py_XDECREF(res);
1557 }
1558#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1559 else {
1560 const char *name = SWIG_TypePrettyName(ty);
1561 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1562 }
1563#endif
1564 }
1565 Py_XDECREF(next);
1566 PyObject_DEL(v);
1567}
1568
1569SWIGRUNTIME PyObject*
1570SwigPyObject_append(PyObject* v, PyObject* next)
1571{
1572 SwigPyObject *sobj = (SwigPyObject *) v;
1573 if (!SwigPyObject_Check(next)) {
1574 PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1575 return NULL;
1576 }
1577 sobj->next = next;
1578 Py_INCREF(next);
1579 return SWIG_Py_Void();
1580}
1581
1582SWIGRUNTIME PyObject*
1583SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1584{
1585 SwigPyObject *sobj = (SwigPyObject *) v;
1586 if (sobj->next) {
1587 Py_INCREF(sobj->next);
1588 return sobj->next;
1589 } else {
1590 return SWIG_Py_Void();
1591 }
1592}
1593
1594SWIGINTERN PyObject*
1595SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1596{
1597 SwigPyObject *sobj = (SwigPyObject *)v;
1598 sobj->own = 0;
1599 return SWIG_Py_Void();
1600}
1601
1602SWIGINTERN PyObject*
1603SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1604{
1605 SwigPyObject *sobj = (SwigPyObject *)v;
1606 sobj->own = SWIG_POINTER_OWN;
1607 return SWIG_Py_Void();
1608}
1609
1610SWIGINTERN PyObject*
1611SwigPyObject_own(PyObject *v, PyObject *args)
1612{
1613 PyObject *val = 0;
1614 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
1615 return NULL;
1616 } else {
1617 SwigPyObject *sobj = (SwigPyObject *)v;
1618 PyObject *obj = PyBool_FromLong(sobj->own);
1619 if (val) {
1620 if (PyObject_IsTrue(val)) {
1621 SwigPyObject_acquire(v,args);
1622 } else {
1623 SwigPyObject_disown(v,args);
1624 }
1625 }
1626 return obj;
1627 }
1628}
1629
1630static PyMethodDef
1632 {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
1633 {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
1634 {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
1635 {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
1636 {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
1637 {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
1638 {0, 0, 0, 0}
1639};
1640
1641SWIGRUNTIME PyTypeObject*
1643 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1644
1645 static PyNumberMethods SwigPyObject_as_number = {
1646 (binaryfunc)0, /*nb_add*/
1647 (binaryfunc)0, /*nb_subtract*/
1648 (binaryfunc)0, /*nb_multiply*/
1649 /* nb_divide removed in Python 3 */
1650#if PY_VERSION_HEX < 0x03000000
1651 (binaryfunc)0, /*nb_divide*/
1652#endif
1653 (binaryfunc)0, /*nb_remainder*/
1654 (binaryfunc)0, /*nb_divmod*/
1655 (ternaryfunc)0,/*nb_power*/
1656 (unaryfunc)0, /*nb_negative*/
1657 (unaryfunc)0, /*nb_positive*/
1658 (unaryfunc)0, /*nb_absolute*/
1659 (inquiry)0, /*nb_nonzero*/
1660 0, /*nb_invert*/
1661 0, /*nb_lshift*/
1662 0, /*nb_rshift*/
1663 0, /*nb_and*/
1664 0, /*nb_xor*/
1665 0, /*nb_or*/
1666#if PY_VERSION_HEX < 0x03000000
1667 0, /*nb_coerce*/
1668#endif
1669 (unaryfunc)SwigPyObject_long, /*nb_int*/
1670#if PY_VERSION_HEX < 0x03000000
1671 (unaryfunc)SwigPyObject_long, /*nb_long*/
1672#else
1673 0, /*nb_reserved*/
1674#endif
1675 (unaryfunc)0, /*nb_float*/
1676#if PY_VERSION_HEX < 0x03000000
1677 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1678 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1679#endif
1680#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1681 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1682#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1683 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1684#else
1685 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1686#endif
1687 };
1688
1689 static PyTypeObject swigpyobject_type;
1690 static int type_init = 0;
1691 if (!type_init) {
1692 const PyTypeObject tmp = {
1693#if PY_VERSION_HEX >= 0x03000000
1694 PyVarObject_HEAD_INIT(NULL, 0)
1695#else
1696 PyObject_HEAD_INIT(NULL)
1697 0, /* ob_size */
1698#endif
1699 "SwigPyObject", /* tp_name */
1700 sizeof(SwigPyObject), /* tp_basicsize */
1701 0, /* tp_itemsize */
1702 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1703 0, /* tp_print */
1704 (getattrfunc)0, /* tp_getattr */
1705 (setattrfunc)0, /* tp_setattr */
1706#if PY_VERSION_HEX >= 0x03000000
1707 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1708#else
1709 (cmpfunc)SwigPyObject_compare, /* tp_compare */
1710#endif
1711 (reprfunc)SwigPyObject_repr, /* tp_repr */
1712 &SwigPyObject_as_number, /* tp_as_number */
1713 0, /* tp_as_sequence */
1714 0, /* tp_as_mapping */
1715 (hashfunc)0, /* tp_hash */
1716 (ternaryfunc)0, /* tp_call */
1717 0, /* tp_str */
1718 PyObject_GenericGetAttr, /* tp_getattro */
1719 0, /* tp_setattro */
1720 0, /* tp_as_buffer */
1721 Py_TPFLAGS_DEFAULT, /* tp_flags */
1722 swigobject_doc, /* tp_doc */
1723 0, /* tp_traverse */
1724 0, /* tp_clear */
1725 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1726 0, /* tp_weaklistoffset */
1727 0, /* tp_iter */
1728 0, /* tp_iternext */
1729 swigobject_methods, /* tp_methods */
1730 0, /* tp_members */
1731 0, /* tp_getset */
1732 0, /* tp_base */
1733 0, /* tp_dict */
1734 0, /* tp_descr_get */
1735 0, /* tp_descr_set */
1736 0, /* tp_dictoffset */
1737 0, /* tp_init */
1738 0, /* tp_alloc */
1739 0, /* tp_new */
1740 0, /* tp_free */
1741 0, /* tp_is_gc */
1742 0, /* tp_bases */
1743 0, /* tp_mro */
1744 0, /* tp_cache */
1745 0, /* tp_subclasses */
1746 0, /* tp_weaklist */
1747 0, /* tp_del */
1748 0, /* tp_version_tag */
1749#if PY_VERSION_HEX >= 0x03040000
1750 0, /* tp_finalize */
1751#endif
1752#if PY_VERSION_HEX >= 0x03080000
1753 0, /* tp_vectorcall */
1754#endif
1755#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
1756 0, /* tp_print */
1757#endif
1758#ifdef COUNT_ALLOCS
1759 0, /* tp_allocs */
1760 0, /* tp_frees */
1761 0, /* tp_maxalloc */
1762 0, /* tp_prev */
1763 0 /* tp_next */
1764#endif
1765 };
1766 swigpyobject_type = tmp;
1767 type_init = 1;
1768 if (PyType_Ready(&swigpyobject_type) < 0)
1769 return NULL;
1770 }
1771 return &swigpyobject_type;
1772}
1773
1774SWIGRUNTIME PyObject *
1775SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1776{
1777 SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1778 if (sobj) {
1779 sobj->ptr = ptr;
1780 sobj->ty = ty;
1781 sobj->own = own;
1782 sobj->next = 0;
1783 }
1784 return (PyObject *)sobj;
1785}
1786
1787/* -----------------------------------------------------------------------------
1788 * Implements a simple Swig Packed type, and use it instead of string
1789 * ----------------------------------------------------------------------------- */
1790
1791typedef struct {
1792 PyObject_HEAD
1793 void *pack;
1795 size_t size;
1796} SwigPyPacked;
1797
1798SWIGRUNTIME PyObject *
1800{
1801 char result[SWIG_BUFFER_SIZE];
1802 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1803 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1804 } else {
1805 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1806 }
1807}
1808
1809SWIGRUNTIME PyObject *
1811{
1812 char result[SWIG_BUFFER_SIZE];
1813 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1814 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1815 } else {
1816 return SWIG_Python_str_FromChar(v->ty->name);
1817 }
1818}
1819
1820SWIGRUNTIME int
1822{
1823 size_t i = v->size;
1824 size_t j = w->size;
1825 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1826 return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
1827}
1828
1829SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
1830
1831SWIGRUNTIME PyTypeObject*
1833 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
1834 return type;
1835}
1836
1838SwigPyPacked_Check(PyObject *op) {
1839 return ((op)->ob_type == SwigPyPacked_TypeOnce())
1840 || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1841}
1842
1843SWIGRUNTIME void
1845{
1846 if (SwigPyPacked_Check(v)) {
1847 SwigPyPacked *sobj = (SwigPyPacked *) v;
1848 free(sobj->pack);
1849 }
1850 PyObject_DEL(v);
1851}
1852
1853SWIGRUNTIME PyTypeObject*
1855 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1856 static PyTypeObject swigpypacked_type;
1857 static int type_init = 0;
1858 if (!type_init) {
1859 const PyTypeObject tmp = {
1860#if PY_VERSION_HEX>=0x03000000
1861 PyVarObject_HEAD_INIT(NULL, 0)
1862#else
1863 PyObject_HEAD_INIT(NULL)
1864 0, /* ob_size */
1865#endif
1866 "SwigPyPacked", /* tp_name */
1867 sizeof(SwigPyPacked), /* tp_basicsize */
1868 0, /* tp_itemsize */
1869 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
1870 0, /* tp_print */
1871 (getattrfunc)0, /* tp_getattr */
1872 (setattrfunc)0, /* tp_setattr */
1873#if PY_VERSION_HEX>=0x03000000
1874 0, /* tp_reserved in 3.0.1 */
1875#else
1876 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
1877#endif
1878 (reprfunc)SwigPyPacked_repr, /* tp_repr */
1879 0, /* tp_as_number */
1880 0, /* tp_as_sequence */
1881 0, /* tp_as_mapping */
1882 (hashfunc)0, /* tp_hash */
1883 (ternaryfunc)0, /* tp_call */
1884 (reprfunc)SwigPyPacked_str, /* tp_str */
1885 PyObject_GenericGetAttr, /* tp_getattro */
1886 0, /* tp_setattro */
1887 0, /* tp_as_buffer */
1888 Py_TPFLAGS_DEFAULT, /* tp_flags */
1889 swigpacked_doc, /* tp_doc */
1890 0, /* tp_traverse */
1891 0, /* tp_clear */
1892 0, /* tp_richcompare */
1893 0, /* tp_weaklistoffset */
1894 0, /* tp_iter */
1895 0, /* tp_iternext */
1896 0, /* tp_methods */
1897 0, /* tp_members */
1898 0, /* tp_getset */
1899 0, /* tp_base */
1900 0, /* tp_dict */
1901 0, /* tp_descr_get */
1902 0, /* tp_descr_set */
1903 0, /* tp_dictoffset */
1904 0, /* tp_init */
1905 0, /* tp_alloc */
1906 0, /* tp_new */
1907 0, /* tp_free */
1908 0, /* tp_is_gc */
1909 0, /* tp_bases */
1910 0, /* tp_mro */
1911 0, /* tp_cache */
1912 0, /* tp_subclasses */
1913 0, /* tp_weaklist */
1914 0, /* tp_del */
1915 0, /* tp_version_tag */
1916#if PY_VERSION_HEX >= 0x03040000
1917 0, /* tp_finalize */
1918#endif
1919#if PY_VERSION_HEX >= 0x03080000
1920 0, /* tp_vectorcall */
1921#endif
1922#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
1923 0, /* tp_print */
1924#endif
1925#ifdef COUNT_ALLOCS
1926 0, /* tp_allocs */
1927 0, /* tp_frees */
1928 0, /* tp_maxalloc */
1929 0, /* tp_prev */
1930 0 /* tp_next */
1931#endif
1932 };
1933 swigpypacked_type = tmp;
1934 type_init = 1;
1935 if (PyType_Ready(&swigpypacked_type) < 0)
1936 return NULL;
1937 }
1938 return &swigpypacked_type;
1939}
1940
1941SWIGRUNTIME PyObject *
1942SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
1943{
1944 SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
1945 if (sobj) {
1946 void *pack = malloc(size);
1947 if (pack) {
1948 memcpy(pack, ptr, size);
1949 sobj->pack = pack;
1950 sobj->ty = ty;
1951 sobj->size = size;
1952 } else {
1953 PyObject_DEL((PyObject *) sobj);
1954 sobj = 0;
1955 }
1956 }
1957 return (PyObject *) sobj;
1958}
1959
1961SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1962{
1963 if (SwigPyPacked_Check(obj)) {
1964 SwigPyPacked *sobj = (SwigPyPacked *)obj;
1965 if (sobj->size != size) return 0;
1966 memcpy(ptr, sobj->pack, size);
1967 return sobj->ty;
1968 } else {
1969 return 0;
1970 }
1971}
1972
1973/* -----------------------------------------------------------------------------
1974 * pointers/data manipulation
1975 * ----------------------------------------------------------------------------- */
1976
1977static PyObject *Swig_This_global = NULL;
1978
1979SWIGRUNTIME PyObject *
1981{
1982 if (Swig_This_global == NULL)
1984 return Swig_This_global;
1985}
1986
1987/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1988
1989/* TODO: I don't know how to implement the fast getset in Python 3 right now */
1990#if PY_VERSION_HEX>=0x03000000
1991#define SWIG_PYTHON_SLOW_GETSET_THIS
1992#endif
1993
1996{
1997 PyObject *obj;
1998
1999 if (SwigPyObject_Check(pyobj))
2000 return (SwigPyObject *) pyobj;
2001
2002#ifdef SWIGPYTHON_BUILTIN
2003 (void)obj;
2004# ifdef PyWeakref_CheckProxy
2005 if (PyWeakref_CheckProxy(pyobj)) {
2006 pyobj = PyWeakref_GET_OBJECT(pyobj);
2007 if (pyobj && SwigPyObject_Check(pyobj))
2008 return (SwigPyObject*) pyobj;
2009 }
2010# endif
2011 return NULL;
2012#else
2013
2014 obj = 0;
2015
2016#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2017 if (PyInstance_Check(pyobj)) {
2018 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2019 } else {
2020 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2021 if (dictptr != NULL) {
2022 PyObject *dict = *dictptr;
2023 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2024 } else {
2025#ifdef PyWeakref_CheckProxy
2026 if (PyWeakref_CheckProxy(pyobj)) {
2027 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2028 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2029 }
2030#endif
2031 obj = PyObject_GetAttr(pyobj,SWIG_This());
2032 if (obj) {
2033 Py_DECREF(obj);
2034 } else {
2035 if (PyErr_Occurred()) PyErr_Clear();
2036 return 0;
2037 }
2038 }
2039 }
2040#else
2041 obj = PyObject_GetAttr(pyobj,SWIG_This());
2042 if (obj) {
2043 Py_DECREF(obj);
2044 } else {
2045 if (PyErr_Occurred()) PyErr_Clear();
2046 return 0;
2047 }
2048#endif
2049 if (obj && !SwigPyObject_Check(obj)) {
2050 /* a PyObject is called 'this', try to get the 'real this'
2051 SwigPyObject from it */
2052 return SWIG_Python_GetSwigThis(obj);
2053 }
2054 return (SwigPyObject *)obj;
2055#endif
2056}
2057
2058/* Acquire a pointer value */
2059
2060SWIGRUNTIME int
2061SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2062 if (own == SWIG_POINTER_OWN) {
2064 if (sobj) {
2065 int oldown = sobj->own;
2066 sobj->own = own;
2067 return oldown;
2068 }
2069 }
2070 return 0;
2071}
2072
2073/* Convert a pointer value */
2074
2075SWIGRUNTIME int
2076SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2077 int res;
2078 SwigPyObject *sobj;
2079 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2080
2081 if (!obj)
2082 return SWIG_ERROR;
2083 if (obj == Py_None && !implicit_conv) {
2084 if (ptr)
2085 *ptr = 0;
2087 }
2088
2089 res = SWIG_ERROR;
2090
2091 sobj = SWIG_Python_GetSwigThis(obj);
2092 if (own)
2093 *own = 0;
2094 while (sobj) {
2095 void *vptr = sobj->ptr;
2096 if (ty) {
2097 swig_type_info *to = sobj->ty;
2098 if (to == ty) {
2099 /* no type cast needed */
2100 if (ptr) *ptr = vptr;
2101 break;
2102 } else {
2103 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2104 if (!tc) {
2105 sobj = (SwigPyObject *)sobj->next;
2106 } else {
2107 if (ptr) {
2108 int newmemory = 0;
2109 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2110 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2111 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2112 if (own)
2113 *own = *own | SWIG_CAST_NEW_MEMORY;
2114 }
2115 }
2116 break;
2117 }
2118 }
2119 } else {
2120 if (ptr) *ptr = vptr;
2121 break;
2122 }
2123 }
2124 if (sobj) {
2125 if (own)
2126 *own = *own | sobj->own;
2127 if (flags & SWIG_POINTER_DISOWN) {
2128 sobj->own = 0;
2129 }
2130 res = SWIG_OK;
2131 } else {
2132 if (implicit_conv) {
2133 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2134 if (data && !data->implicitconv) {
2135 PyObject *klass = data->klass;
2136 if (klass) {
2137 PyObject *impconv;
2138 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2139 impconv = SWIG_Python_CallFunctor(klass, obj);
2140 data->implicitconv = 0;
2141 if (PyErr_Occurred()) {
2142 PyErr_Clear();
2143 impconv = 0;
2144 }
2145 if (impconv) {
2146 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2147 if (iobj) {
2148 void *vptr;
2149 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2150 if (SWIG_IsOK(res)) {
2151 if (ptr) {
2152 *ptr = vptr;
2153 /* transfer the ownership to 'ptr' */
2154 iobj->own = 0;
2155 res = SWIG_AddCast(res);
2156 res = SWIG_AddNewMask(res);
2157 } else {
2158 res = SWIG_AddCast(res);
2159 }
2160 }
2161 }
2162 Py_DECREF(impconv);
2163 }
2164 }
2165 }
2166 if (!SWIG_IsOK(res) && obj == Py_None) {
2167 if (ptr)
2168 *ptr = 0;
2169 if (PyErr_Occurred())
2170 PyErr_Clear();
2171 res = SWIG_OK;
2172 }
2173 }
2174 }
2175 return res;
2176}
2177
2178/* Convert a function ptr value */
2179
2180SWIGRUNTIME int
2181SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2182 if (!PyCFunction_Check(obj)) {
2183 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2184 } else {
2185 void *vptr = 0;
2186 swig_cast_info *tc;
2187
2188 /* here we get the method pointer for callbacks */
2189 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2190 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2191 if (desc)
2192 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2193 if (!desc)
2194 return SWIG_ERROR;
2195 tc = SWIG_TypeCheck(desc,ty);
2196 if (tc) {
2197 int newmemory = 0;
2198 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2199 assert(!newmemory); /* newmemory handling not yet implemented */
2200 } else {
2201 return SWIG_ERROR;
2202 }
2203 return SWIG_OK;
2204 }
2205}
2206
2207/* Convert a packed pointer value */
2208
2209SWIGRUNTIME int
2210SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2211 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2212 if (!to) return SWIG_ERROR;
2213 if (ty) {
2214 if (to != ty) {
2215 /* check type cast? */
2216 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2217 if (!tc) return SWIG_ERROR;
2218 }
2219 }
2220 return SWIG_OK;
2221}
2222
2223/* -----------------------------------------------------------------------------
2224 * Create a new pointer object
2225 * ----------------------------------------------------------------------------- */
2226
2227/*
2228 Create a new instance object, without calling __init__, and set the
2229 'this' attribute.
2230*/
2231
2232SWIGRUNTIME PyObject*
2234{
2235 PyObject *inst = 0;
2236 PyObject *newraw = data->newraw;
2237 if (newraw) {
2238 inst = PyObject_Call(newraw, data->newargs, NULL);
2239 if (inst) {
2240#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2241 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2242 if (dictptr != NULL) {
2243 PyObject *dict = *dictptr;
2244 if (dict == NULL) {
2245 dict = PyDict_New();
2246 *dictptr = dict;
2247 PyDict_SetItem(dict, SWIG_This(), swig_this);
2248 }
2249 }
2250#else
2251 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2252 Py_DECREF(inst);
2253 inst = 0;
2254 }
2255#endif
2256 }
2257 } else {
2258#if PY_VERSION_HEX >= 0x03000000
2259 PyObject *empty_args = PyTuple_New(0);
2260 if (empty_args) {
2261 PyObject *empty_kwargs = PyDict_New();
2262 if (empty_kwargs) {
2263 inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
2264 Py_DECREF(empty_kwargs);
2265 if (inst) {
2266 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2267 Py_DECREF(inst);
2268 inst = 0;
2269 } else {
2270 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2271 }
2272 }
2273 }
2274 Py_DECREF(empty_args);
2275 }
2276#else
2277 PyObject *dict = PyDict_New();
2278 if (dict) {
2279 PyDict_SetItem(dict, SWIG_This(), swig_this);
2280 inst = PyInstance_NewRaw(data->newargs, dict);
2281 Py_DECREF(dict);
2282 }
2283#endif
2284 }
2285 return inst;
2286}
2287
2288SWIGRUNTIME int
2289SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2290{
2291#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2292 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2293 if (dictptr != NULL) {
2294 PyObject *dict = *dictptr;
2295 if (dict == NULL) {
2296 dict = PyDict_New();
2297 *dictptr = dict;
2298 }
2299 return PyDict_SetItem(dict, SWIG_This(), swig_this);
2300 }
2301#endif
2302 return PyObject_SetAttr(inst, SWIG_This(), swig_this);
2303}
2304
2305
2306SWIGINTERN PyObject *
2308 PyObject *obj[2];
2309 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2310 return NULL;
2311 } else {
2312 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2313 if (sthis) {
2314 SwigPyObject_append((PyObject*) sthis, obj[1]);
2315 } else {
2316 if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
2317 return NULL;
2318 }
2319 return SWIG_Py_Void();
2320 }
2321}
2322
2323/* Create a new pointer object */
2324
2325SWIGRUNTIME PyObject *
2326SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2327 SwigPyClientData *clientdata;
2328 PyObject * robj;
2329 int own;
2330
2331 if (!ptr)
2332 return SWIG_Py_Void();
2333
2334 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2335 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2336 if (clientdata && clientdata->pytype) {
2337 SwigPyObject *newobj;
2338 if (flags & SWIG_BUILTIN_TP_INIT) {
2339 newobj = (SwigPyObject*) self;
2340 if (newobj->ptr) {
2341 PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2342 while (newobj->next)
2343 newobj = (SwigPyObject *) newobj->next;
2344 newobj->next = next_self;
2345 newobj = (SwigPyObject *)next_self;
2346#ifdef SWIGPYTHON_BUILTIN
2347 newobj->dict = 0;
2348#endif
2349 }
2350 } else {
2351 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2352#ifdef SWIGPYTHON_BUILTIN
2353 newobj->dict = 0;
2354#endif
2355 }
2356 if (newobj) {
2357 newobj->ptr = ptr;
2358 newobj->ty = type;
2359 newobj->own = own;
2360 newobj->next = 0;
2361 return (PyObject*) newobj;
2362 }
2363 return SWIG_Py_Void();
2364 }
2365
2366 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2367
2368 robj = SwigPyObject_New(ptr, type, own);
2369 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2370 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2371 Py_DECREF(robj);
2372 robj = inst;
2373 }
2374 return robj;
2375}
2376
2377/* Create a new packed object */
2378
2379SWIGRUNTIMEINLINE PyObject *
2380SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2381 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2382}
2383
2384/* -----------------------------------------------------------------------------*
2385 * Get type list
2386 * -----------------------------------------------------------------------------*/
2387
2388#ifdef SWIG_LINK_RUNTIME
2389void *SWIG_ReturnGlobalTypeList(void *);
2390#endif
2391
2394 static void *type_pointer = (void *)0;
2395 /* first check if module already created */
2396 if (!type_pointer) {
2397#ifdef SWIG_LINK_RUNTIME
2398 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2399#else
2400 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2401 if (PyErr_Occurred()) {
2402 PyErr_Clear();
2403 type_pointer = (void *)0;
2404 }
2405#endif
2406 }
2407 return (swig_module_info *) type_pointer;
2408}
2409
2410SWIGRUNTIME void
2412{
2413 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2414 swig_type_info **types = swig_module->types;
2415 size_t i;
2416 for (i =0; i < swig_module->size; ++i) {
2417 swig_type_info *ty = types[i];
2418 if (ty->owndata) {
2420 if (data) SwigPyClientData_Del(data);
2421 }
2422 }
2423 Py_DECREF(SWIG_This());
2424 Swig_This_global = NULL;
2425}
2426
2427SWIGRUNTIME void
2429#if PY_VERSION_HEX >= 0x03000000
2430 /* Add a dummy module object into sys.modules */
2431 PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2432#else
2433 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2434 PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2435#endif
2436 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2437 if (pointer && module) {
2438 PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2439 } else {
2440 Py_XDECREF(pointer);
2441 }
2442}
2443
2444/* The python cached type query */
2445SWIGRUNTIME PyObject *
2447 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2448 return cache;
2449}
2450
2452SWIG_Python_TypeQuery(const char *type)
2453{
2454 PyObject *cache = SWIG_Python_TypeCache();
2455 PyObject *key = SWIG_Python_str_FromChar(type);
2456 PyObject *obj = PyDict_GetItem(cache, key);
2457 swig_type_info *descriptor;
2458 if (obj) {
2459 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2460 } else {
2462 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2463 if (descriptor) {
2464 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2465 PyDict_SetItem(cache, key, obj);
2466 Py_DECREF(obj);
2467 }
2468 }
2469 Py_DECREF(key);
2470 return descriptor;
2471}
2472
2473/*
2474 For backward compatibility only
2475*/
2476#define SWIG_POINTER_EXCEPTION 0
2477#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2478#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2479
2480SWIGRUNTIME int
2481SWIG_Python_AddErrMesg(const char* mesg, int infront)
2482{
2483 if (PyErr_Occurred()) {
2484 PyObject *type = 0;
2485 PyObject *value = 0;
2486 PyObject *traceback = 0;
2487 PyErr_Fetch(&type, &value, &traceback);
2488 if (value) {
2489 PyObject *old_str = PyObject_Str(value);
2490 const char *tmp = SWIG_Python_str_AsChar(old_str);
2491 const char *errmesg = tmp ? tmp : "Invalid error message";
2492 Py_XINCREF(type);
2493 PyErr_Clear();
2494 if (infront) {
2495 PyErr_Format(type, "%s %s", mesg, errmesg);
2496 } else {
2497 PyErr_Format(type, "%s %s", errmesg, mesg);
2498 }
2500 Py_DECREF(old_str);
2501 }
2502 return 1;
2503 } else {
2504 return 0;
2505 }
2506}
2507
2508SWIGRUNTIME int
2510{
2511 if (PyErr_Occurred()) {
2512 /* add information about failing argument */
2513 char mesg[256];
2514 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2515 return SWIG_Python_AddErrMesg(mesg, 1);
2516 } else {
2517 return 0;
2518 }
2519}
2520
2521SWIGRUNTIMEINLINE const char *
2523{
2524 SwigPyObject *v = (SwigPyObject *)self;
2525 swig_type_info *ty = v ? v->ty : 0;
2526 return ty ? ty->str : "";
2527}
2528
2529SWIGRUNTIME void
2530SWIG_Python_TypeError(const char *type, PyObject *obj)
2531{
2532 if (type) {
2533#if defined(SWIG_COBJECT_TYPES)
2534 if (obj && SwigPyObject_Check(obj)) {
2535 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2536 if (otype) {
2537 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2538 type, otype);
2539 return;
2540 }
2541 } else
2542#endif
2543 {
2544 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2545 if (otype) {
2546 PyObject *str = PyObject_Str(obj);
2547 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2548 if (cstr) {
2549 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2550 type, otype, cstr);
2552 } else {
2553 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2554 type, otype);
2555 }
2556 Py_XDECREF(str);
2557 return;
2558 }
2559 }
2560 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2561 } else {
2562 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2563 }
2564}
2565
2566
2567/* Convert a pointer value, signal an exception on a type mismatch */
2568SWIGRUNTIME void *
2569SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2570 void *result;
2571 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2572 PyErr_Clear();
2573#if SWIG_POINTER_EXCEPTION
2574 if (flags) {
2576 SWIG_Python_ArgFail(argnum);
2577 }
2578#endif
2579 }
2580 return result;
2581}
2582
2583#ifdef SWIGPYTHON_BUILTIN
2584SWIGRUNTIME int
2585SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2586 PyTypeObject *tp = obj->ob_type;
2587 PyObject *descr;
2588 PyObject *encoded_name;
2589 descrsetfunc f;
2590 int res = -1;
2591
2592# ifdef Py_USING_UNICODE
2593 if (PyString_Check(name)) {
2594 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2595 if (!name)
2596 return -1;
2597 } else if (!PyUnicode_Check(name))
2598# else
2599 if (!PyString_Check(name))
2600# endif
2601 {
2602 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2603 return -1;
2604 } else {
2605 Py_INCREF(name);
2606 }
2607
2608 if (!tp->tp_dict) {
2609 if (PyType_Ready(tp) < 0)
2610 goto done;
2611 }
2612
2613 descr = _PyType_Lookup(tp, name);
2614 f = NULL;
2615 if (descr != NULL)
2616 f = descr->ob_type->tp_descr_set;
2617 if (!f) {
2618 if (PyString_Check(name)) {
2619 encoded_name = name;
2620 Py_INCREF(name);
2621 } else {
2622 encoded_name = PyUnicode_AsUTF8String(name);
2623 if (!encoded_name)
2624 return -1;
2625 }
2626 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2627 Py_DECREF(encoded_name);
2628 } else {
2629 res = f(descr, obj, value);
2630 }
2631
2632 done:
2633 Py_DECREF(name);
2634 return res;
2635}
2636#endif
2637
2638
2639#ifdef __cplusplus
2640}
2641#endif
2642
2643
2644
2645#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2646
2647#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2648
2649
2650
2651#ifdef __cplusplus
2652extern "C" {
2653#endif
2654
2655/* Method creation and docstring support functions */
2656
2657SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
2658SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
2659SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
2660
2661#ifdef __cplusplus
2662}
2663#endif
2664
2665
2666/* -------- TYPES TABLE (BEGIN) -------- */
2667
2668#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2669#define SWIGTYPE_p_PLcGrid swig_types[1]
2670#define SWIGTYPE_p_PLcGrid2 swig_types[2]
2671#define SWIGTYPE_p_char swig_types[3]
2672#define SWIGTYPE_p_double swig_types[4]
2673#define SWIGTYPE_p_f_double_double__int swig_types[5]
2674#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2675#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2676#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2677#define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2678#define SWIGTYPE_p_int swig_types[10]
2679#define SWIGTYPE_p_p_char swig_types[11]
2680#define SWIGTYPE_p_p_double swig_types[12]
2681#define SWIGTYPE_p_unsigned_int swig_types[13]
2683static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2684#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2685#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2686
2687/* -------- TYPES TABLE (END) -------- */
2688
2689#ifdef SWIG_TypeQuery
2690# undef SWIG_TypeQuery
2691#endif
2692#define SWIG_TypeQuery SWIG_Python_TypeQuery
2693
2694/*-----------------------------------------------
2695 @(target):= _plplotc.so
2696 ------------------------------------------------*/
2697#if PY_VERSION_HEX >= 0x03000000
2698# define SWIG_init PyInit__plplotc
2699
2700#else
2701# define SWIG_init init_plplotc
2702
2703#endif
2704#define SWIG_name "_plplotc"
2705
2706#define SWIGVERSION 0x040002
2707#define SWIG_VERSION SWIGVERSION
2708
2709
2710#define SWIG_as_voidptr(a) (void *)((const void *)(a))
2711#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2712
2713
2714#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
2715#include <arrayobject.h>
2716#include "plplot.h"
2717#include "plplotP.h"
2718
2719#define NPY_PLINT NPY_INT32
2720
2721#ifdef PL_DOUBLE
2722#define NPY_PLFLT NPY_FLOAT64
2723#else
2724#define NPY_PLFLT NPY_FLOAT32
2725#endif
2726
2727// python-1.5 compatibility mode?
2728#if !defined ( PySequence_Fast_GET_ITEM )
2729 #define PySequence_Fast_GET_ITEM PySequence_GetItem
2730#endif
2731#define PySequence_Size PySequence_Length
2732
2733
2734 static PLINT Alen = 0;
2735 static PLINT Xlen = 0, Ylen = 0;
2736
2737
2738SWIGINTERN int
2739SWIG_AsVal_double (PyObject *obj, double *val)
2740{
2741 int res = SWIG_TypeError;
2742 if (PyFloat_Check(obj)) {
2743 if (val) *val = PyFloat_AsDouble(obj);
2744 return SWIG_OK;
2745#if PY_VERSION_HEX < 0x03000000
2746 } else if (PyInt_Check(obj)) {
2747 if (val) *val = (double) PyInt_AsLong(obj);
2748 return SWIG_OK;
2749#endif
2750 } else if (PyLong_Check(obj)) {
2751 double v = PyLong_AsDouble(obj);
2752 if (!PyErr_Occurred()) {
2753 if (val) *val = v;
2754 return SWIG_OK;
2755 } else {
2756 PyErr_Clear();
2757 }
2758 }
2759#ifdef SWIG_PYTHON_CAST_MODE
2760 {
2761 int dispatch = 0;
2762 double d = PyFloat_AsDouble(obj);
2763 if (!PyErr_Occurred()) {
2764 if (val) *val = d;
2765 return SWIG_AddCast(SWIG_OK);
2766 } else {
2767 PyErr_Clear();
2768 }
2769 if (!dispatch) {
2770 long v = PyLong_AsLong(obj);
2771 if (!PyErr_Occurred()) {
2772 if (val) *val = v;
2774 } else {
2775 PyErr_Clear();
2776 }
2777 }
2778 }
2779#endif
2780 return res;
2781}
2782
2783
2784 #define SWIG_From_double PyFloat_FromDouble
2785
2786
2787 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2788 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2789 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2790 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2791 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2793 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
2794
2795
2796SWIGINTERNINLINE PyObject*
2798{
2799 return PyInt_FromLong((long) value);
2800}
2801
2802
2803#include <limits.h>
2804#if !defined(SWIG_NO_LLONG_MAX)
2805# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2806# define LLONG_MAX __LONG_LONG_MAX__
2807# define LLONG_MIN (-LLONG_MAX - 1LL)
2808# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2809# endif
2810#endif
2811
2812
2813#include <float.h>
2814
2815
2816#include <math.h>
2817
2818
2820SWIG_CanCastAsInteger(double *d, double min, double max) {
2821 double x = *d;
2822 if ((min <= x && x <= max)) {
2823 double fx = floor(x);
2824 double cx = ceil(x);
2825 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2826 if ((errno == EDOM) || (errno == ERANGE)) {
2827 errno = 0;
2828 } else {
2829 double summ, reps, diff;
2830 if (rd < x) {
2831 diff = x - rd;
2832 } else if (rd > x) {
2833 diff = rd - x;
2834 } else {
2835 return 1;
2836 }
2837 summ = rd + x;
2838 reps = diff/summ;
2839 if (reps < 8*DBL_EPSILON) {
2840 *d = rd;
2841 return 1;
2842 }
2843 }
2844 }
2845 return 0;
2846}
2847
2848
2849SWIGINTERN int
2850SWIG_AsVal_long (PyObject *obj, long* val)
2851{
2852#if PY_VERSION_HEX < 0x03000000
2853 if (PyInt_Check(obj)) {
2854 if (val) *val = PyInt_AsLong(obj);
2855 return SWIG_OK;
2856 } else
2857#endif
2858 if (PyLong_Check(obj)) {
2859 long v = PyLong_AsLong(obj);
2860 if (!PyErr_Occurred()) {
2861 if (val) *val = v;
2862 return SWIG_OK;
2863 } else {
2864 PyErr_Clear();
2865 return SWIG_OverflowError;
2866 }
2867 }
2868#ifdef SWIG_PYTHON_CAST_MODE
2869 {
2870 int dispatch = 0;
2871 long v = PyInt_AsLong(obj);
2872 if (!PyErr_Occurred()) {
2873 if (val) *val = v;
2874 return SWIG_AddCast(SWIG_OK);
2875 } else {
2876 PyErr_Clear();
2877 }
2878 if (!dispatch) {
2879 double d;
2880 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2881 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2882 if (val) *val = (long)(d);
2883 return res;
2884 }
2885 }
2886 }
2887#endif
2888 return SWIG_TypeError;
2889}
2890
2891
2892SWIGINTERN int
2893SWIG_AsVal_int (PyObject * obj, int *val)
2894{
2895 long v;
2896 int res = SWIG_AsVal_long (obj, &v);
2897 if (SWIG_IsOK(res)) {
2898 if ((v < INT_MIN || v > INT_MAX)) {
2899 return SWIG_OverflowError;
2900 } else {
2901 if (val) *val = (int)(v);
2902 }
2903 }
2904 return res;
2905}
2906
2907
2908SWIGINTERN int
2909SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
2910{
2911#if PY_VERSION_HEX < 0x03000000
2912 if (PyInt_Check(obj)) {
2913 long v = PyInt_AsLong(obj);
2914 if (v >= 0) {
2915 if (val) *val = v;
2916 return SWIG_OK;
2917 } else {
2918 return SWIG_OverflowError;
2919 }
2920 } else
2921#endif
2922 if (PyLong_Check(obj)) {
2923 unsigned long v = PyLong_AsUnsignedLong(obj);
2924 if (!PyErr_Occurred()) {
2925 if (val) *val = v;
2926 return SWIG_OK;
2927 } else {
2928 PyErr_Clear();
2929 return SWIG_OverflowError;
2930 }
2931 }
2932#ifdef SWIG_PYTHON_CAST_MODE
2933 {
2934 int dispatch = 0;
2935 unsigned long v = PyLong_AsUnsignedLong(obj);
2936 if (!PyErr_Occurred()) {
2937 if (val) *val = v;
2938 return SWIG_AddCast(SWIG_OK);
2939 } else {
2940 PyErr_Clear();
2941 }
2942 if (!dispatch) {
2943 double d;
2944 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2945 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2946 if (val) *val = (unsigned long)(d);
2947 return res;
2948 }
2949 }
2950 }
2951#endif
2952 return SWIG_TypeError;
2953}
2954
2955
2956SWIGINTERN int
2957SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
2958{
2959 unsigned long v;
2960 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2961 if (SWIG_IsOK(res)) {
2962 if ((v > UINT_MAX)) {
2963 return SWIG_OverflowError;
2964 } else {
2965 if (val) *val = (unsigned int)(v);
2966 }
2967 }
2968 return res;
2969}
2970
2971
2972SWIGINTERNINLINE PyObject*
2974{
2975 return PyInt_FromSize_t((size_t) value);
2976}
2977
2978
2981{
2982 static int init = 0;
2983 static swig_type_info* info = 0;
2984 if (!init) {
2985 info = SWIG_TypeQuery("_p_char");
2986 init = 1;
2987 }
2988 return info;
2989}
2990
2991
2992SWIGINTERN int
2993SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2994{
2995#if PY_VERSION_HEX>=0x03000000
2996#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
2997 if (PyBytes_Check(obj))
2998#else
2999 if (PyUnicode_Check(obj))
3000#endif
3001#else
3002 if (PyString_Check(obj))
3003#endif
3004 {
3005 char *cstr; Py_ssize_t len;
3006 int ret = SWIG_OK;
3007#if PY_VERSION_HEX>=0x03000000
3008#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3009 if (!alloc && cptr) {
3010 /* We can't allow converting without allocation, since the internal
3011 representation of string in Python 3 is UCS-2/UCS-4 but we require
3012 a UTF-8 representation.
3013 TODO(bhy) More detailed explanation */
3014 return SWIG_RuntimeError;
3015 }
3016 obj = PyUnicode_AsUTF8String(obj);
3017 if (!obj)
3018 return SWIG_TypeError;
3019 if (alloc)
3020 *alloc = SWIG_NEWOBJ;
3021#endif
3022 if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
3023 return SWIG_TypeError;
3024#else
3025 if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
3026 return SWIG_TypeError;
3027#endif
3028 if (cptr) {
3029 if (alloc) {
3030 if (*alloc == SWIG_NEWOBJ) {
3031 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3032 *alloc = SWIG_NEWOBJ;
3033 } else {
3034 *cptr = cstr;
3035 *alloc = SWIG_OLDOBJ;
3036 }
3037 } else {
3038#if PY_VERSION_HEX>=0x03000000
3039#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3040 *cptr = PyBytes_AsString(obj);
3041#else
3042 assert(0); /* Should never reach here with Unicode strings in Python 3 */
3043#endif
3044#else
3045 *cptr = SWIG_Python_str_AsChar(obj);
3046 if (!*cptr)
3047 ret = SWIG_TypeError;
3048#endif
3049 }
3050 }
3051 if (psize) *psize = len + 1;
3052#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3053 Py_XDECREF(obj);
3054#endif
3055 return ret;
3056 } else {
3057#if defined(SWIG_PYTHON_2_UNICODE)
3058#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3059#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3060#endif
3061#if PY_VERSION_HEX<0x03000000
3062 if (PyUnicode_Check(obj)) {
3063 char *cstr; Py_ssize_t len;
3064 if (!alloc && cptr) {
3065 return SWIG_RuntimeError;
3066 }
3067 obj = PyUnicode_AsUTF8String(obj);
3068 if (!obj)
3069 return SWIG_TypeError;
3070 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3071 if (cptr) {
3072 if (alloc) *alloc = SWIG_NEWOBJ;
3073 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3074 }
3075 if (psize) *psize = len + 1;
3076
3077 Py_XDECREF(obj);
3078 return SWIG_OK;
3079 } else {
3080 Py_XDECREF(obj);
3081 }
3082 }
3083#endif
3084#endif
3085
3086 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3087 if (pchar_descriptor) {
3088 void* vptr = 0;
3089 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3090 if (cptr) *cptr = (char *) vptr;
3091 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3092 if (alloc) *alloc = SWIG_OLDOBJ;
3093 return SWIG_OK;
3094 }
3095 }
3096 }
3097 return SWIG_TypeError;
3098}
3099
3100
3101SWIGINTERN int
3102SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3103{
3104 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3105 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3106 if (SWIG_IsOK(res)) {
3107 /* special case of single char conversion when we don't need space for NUL */
3108 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3109 if (csize <= size) {
3110 if (val) {
3111 if (csize) memcpy(val, cptr, csize*sizeof(char));
3112 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3113 }
3114 if (alloc == SWIG_NEWOBJ) {
3115 free((char*)cptr);
3116 res = SWIG_DelNewMask(res);
3117 }
3118 return res;
3119 }
3120 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3121 }
3122 return SWIG_TypeError;
3123}
3124
3125
3126SWIGINTERNINLINE PyObject *
3127SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3128{
3129 if (carray) {
3130 if (size > INT_MAX) {
3131 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3132 return pchar_descriptor ?
3133 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3134 } else {
3135#if PY_VERSION_HEX >= 0x03000000
3136#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3137 return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3138#else
3139 return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3140#endif
3141#else
3142 return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3143#endif
3144 }
3145 } else {
3146 return SWIG_Py_Void();
3147 }
3148}
3149
3150
3151SWIGINTERN size_t
3152SWIG_strnlen(const char* s, size_t maxlen)
3153{
3154 const char *p;
3155 for (p = s; maxlen-- && *p; p++)
3156 ;
3157 return p - s;
3158}
3159
3160
3161
3162
3163
3164#define t_output_helper SWIG_Python_AppendOutput
3165
3166
3167SWIGINTERN int
3168SWIG_AsVal_char (PyObject * obj, char *val)
3169{
3170 int res = SWIG_AsCharArray(obj, val, 1);
3171 if (!SWIG_IsOK(res)) {
3172 long v;
3173 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3174 if (SWIG_IsOK(res)) {
3175 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3176 if (val) *val = (char)(v);
3177 } else {
3178 res = SWIG_OverflowError;
3179 }
3180 }
3181 }
3182 return res;
3183}
3184
3185#ifdef __cplusplus
3186extern "C" {
3187#endif
3188
3189 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3190
3191// some really twisted stuff to allow calling a single precision library from python
3192 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3193 {
3194 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3195 mindims, maxdims );
3196 if ( !tmp )
3197 {
3198 // could be an incoming long array which can't be "safely" converted, do it anyway
3199 if ( PyArray_Check( in ) )
3200 {
3201 PyErr_Clear();
3202 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3203 }
3204 }
3205 return tmp;
3206 }
3207
3208
3209#define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3210
3211SWIGINTERN PyObject *_wrap_pltr0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3212 PyObject *resultobj = 0;
3213 PLFLT arg1 ;
3214 PLFLT arg2 ;
3215 PLFLT *arg3 = (PLFLT *) 0 ;
3216 PLFLT *arg4 = (PLFLT *) 0 ;
3217 PLPointer arg5 = (PLPointer) 0 ;
3218 double val1 ;
3219 int ecode1 = 0 ;
3220 double val2 ;
3221 int ecode2 = 0 ;
3222 PLFLT temp3 ;
3223 int res3 = SWIG_TMPOBJ ;
3224 PLFLT temp4 ;
3225 int res4 = SWIG_TMPOBJ ;
3226 PyObject *swig_obj[2] ;
3227
3228 arg3 = &temp3;
3229 arg4 = &temp4;
3230 {
3231 arg5 = NULL;
3232 }
3233 if (!SWIG_Python_UnpackTuple(args, "pltr0", 2, 2, swig_obj)) SWIG_fail;
3234 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3235 if (!SWIG_IsOK(ecode1)) {
3236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3237 }
3238 arg1 = (PLFLT)(val1);
3239 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3240 if (!SWIG_IsOK(ecode2)) {
3241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3242 }
3243 arg2 = (PLFLT)(val2);
3244 pltr0(arg1,arg2,arg3,arg4,arg5);
3245 resultobj = SWIG_Py_Void();
3246 if (SWIG_IsTmpObj(res3)) {
3247 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3248 } else {
3249 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3251 }
3252 if (SWIG_IsTmpObj(res4)) {
3253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3254 } else {
3255 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3257 }
3258 return resultobj;
3259fail:
3260 return NULL;
3261}
3262
3263
3264
3265 PyArrayObject *pltr_xg, *pltr_yg;
3268
3269 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3270 void cleanup_PLcGrid1( void );
3271 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3272 void cleanup_PLcGrid2( void );
3273
3274 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3275 {
3276 // fprintf(stderr, "marshal PLcGrid1\n");
3277 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3278 {
3279 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3280 return NULL;
3281 }
3282 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3283 NPY_PLFLT, 1, 1 );
3284 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3285 NPY_PLFLT, 1, 1 );
3286 if ( pltr_xg == 0 || pltr_yg == 0 )
3287 {
3288 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3289 return NULL;
3290 }
3291 tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3292 tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3293 if ( isimg == 0 )
3294 {
3295 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3296 {
3297 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3298 return NULL;
3299 }
3300 }
3301 else
3302 {
3303 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3304 {
3305 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3306 return NULL;
3307 }
3308 }
3309 tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3310 tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3311 return &tmpGrid1;
3312 }
3313
3314 void cleanup_PLcGrid1( void )
3315 {
3316 // fprintf(stderr, "cleanup PLcGrid1\n");
3317 Py_CLEAR( pltr_xg );
3318 Py_CLEAR( pltr_yg );
3319 }
3320
3321 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3322 {
3323 int i, size;
3324 // fprintf(stderr, "marshal PLcGrid2\n");
3325 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3326 {
3327 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3328 return NULL;
3329 }
3330 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3331 NPY_PLFLT, 2, 2 );
3332 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3333 NPY_PLFLT, 2, 2 );
3334 if ( pltr_xg == 0 || pltr_yg == 0 )
3335 {
3336 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3337 return NULL;
3338 }
3339 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3340 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3341 {
3342 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3343 return NULL;
3344 }
3345 tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3346 tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3347 if ( isimg == 0 )
3348 {
3349 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3350 {
3351 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3352 return NULL;
3353 }
3354 }
3355 else
3356 {
3357 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3358 {
3359 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3360 return NULL;
3361 }
3362 }
3363 size = tmpGrid2.ny;
3364 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3365 for ( i = 0; i < tmpGrid2.nx; i++ )
3366 tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3367 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3368 for ( i = 0; i < tmpGrid2.nx; i++ )
3369 tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3370 return &tmpGrid2;
3371 }
3372
3373 void cleanup_PLcGrid2( void )
3374 {
3375 // fprintf(stderr, "cleanup PLcGrid2\n");
3376 free( tmpGrid2.xg );
3377 free( tmpGrid2.yg );
3378 Py_CLEAR( pltr_xg );
3379 Py_CLEAR( pltr_yg );
3380 }
3381
3382SWIGINTERN PyObject *_wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3383 PyObject *resultobj = 0;
3384 PLFLT arg1 ;
3385 PLFLT arg2 ;
3386 PLFLT *arg3 = (PLFLT *) 0 ;
3387 PLFLT *arg4 = (PLFLT *) 0 ;
3388 PLcGrid *arg5 = (PLcGrid *) 0 ;
3389 double val1 ;
3390 int ecode1 = 0 ;
3391 double val2 ;
3392 int ecode2 = 0 ;
3393 PLFLT temp3 ;
3394 int res3 = SWIG_TMPOBJ ;
3395 PLFLT temp4 ;
3396 int res4 = SWIG_TMPOBJ ;
3397 PyObject *swig_obj[3] ;
3398
3399 arg3 = &temp3;
3400 arg4 = &temp4;
3401 if (!SWIG_Python_UnpackTuple(args, "pltr1", 3, 3, swig_obj)) SWIG_fail;
3402 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3403 if (!SWIG_IsOK(ecode1)) {
3404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3405 }
3406 arg1 = (PLFLT)(val1);
3407 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3408 if (!SWIG_IsOK(ecode2)) {
3409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3410 }
3411 arg2 = (PLFLT)(val2);
3412 {
3413 arg5 = marshal_PLcGrid1( swig_obj[2], 0 );
3414 if ( !arg5 )
3415 return NULL;
3416 }
3417 pltr1(arg1,arg2,arg3,arg4,arg5);
3418 resultobj = SWIG_Py_Void();
3419 if (SWIG_IsTmpObj(res3)) {
3420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3421 } else {
3422 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3424 }
3425 if (SWIG_IsTmpObj(res4)) {
3426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3427 } else {
3428 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3430 }
3431 {
3433 }
3434 return resultobj;
3435fail:
3436 {
3438 }
3439 return NULL;
3440}
3441
3442
3443SWIGINTERN PyObject *_wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3444 PyObject *resultobj = 0;
3445 PLFLT arg1 ;
3446 PLFLT arg2 ;
3447 PLFLT *arg3 = (PLFLT *) 0 ;
3448 PLFLT *arg4 = (PLFLT *) 0 ;
3449 PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3450 double val1 ;
3451 int ecode1 = 0 ;
3452 double val2 ;
3453 int ecode2 = 0 ;
3454 PLFLT temp3 ;
3455 int res3 = SWIG_TMPOBJ ;
3456 PLFLT temp4 ;
3457 int res4 = SWIG_TMPOBJ ;
3458 PyObject *swig_obj[3] ;
3459
3460 arg3 = &temp3;
3461 arg4 = &temp4;
3462 if (!SWIG_Python_UnpackTuple(args, "pltr2", 3, 3, swig_obj)) SWIG_fail;
3463 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3464 if (!SWIG_IsOK(ecode1)) {
3465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3466 }
3467 arg1 = (PLFLT)(val1);
3468 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3469 if (!SWIG_IsOK(ecode2)) {
3470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3471 }
3472 arg2 = (PLFLT)(val2);
3473 {
3474 arg5 = marshal_PLcGrid2( swig_obj[2], 0 );
3475 if ( !arg5 )
3476 return NULL;
3477 }
3478 pltr2(arg1,arg2,arg3,arg4,arg5);
3479 resultobj = SWIG_Py_Void();
3480 if (SWIG_IsTmpObj(res3)) {
3481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3482 } else {
3483 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3484 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3485 }
3486 if (SWIG_IsTmpObj(res4)) {
3487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3488 } else {
3489 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3491 }
3492 {
3494 }
3495 return resultobj;
3496fail:
3497 {
3499 }
3500 return NULL;
3501}
3502
3503
3504
3505 // helper code for handling the callback
3506#if 0
3507 static PyInterpreterState *save_interp = NULL;
3508#endif
3510 PyObject* python_pltr = NULL;
3511 PyObject* python_f2eval = NULL;
3512 PyObject* python_ct = NULL;
3513 PyObject* python_mapform = NULL;
3514 PyObject* python_label = NULL;
3515
3516#if 0
3517#define MY_BLOCK_THREADS { \
3518 PyThreadState *prev_state, *new_state; \
3519 /* need to have started a thread at some stage */ \
3520 /* for the following to work */ \
3521 PyEval_AcquireLock(); \
3522 new_state = PyThreadState_New( save_interp ); \
3523 prev_state = PyThreadState_Swap( new_state );
3524#define MY_UNBLOCK_THREADS \
3525 new_state = PyThreadState_Swap( prev_state ); \
3526 PyThreadState_Clear( new_state ); \
3527 PyEval_ReleaseLock(); \
3528 PyThreadState_Delete( new_state ); \
3529 }
3530#else
3531#define MY_BLOCK_THREADS
3532#define MY_UNBLOCK_THREADS
3533#endif
3534
3535// Function prototypes
3536 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
3538 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
3539 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
3540 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
3541 pltr_func marshal_pltr( PyObject* input );
3542 void cleanup_pltr( void );
3543 ct_func marshal_ct( PyObject* input );
3544 void cleanup_ct( void );
3545 mapform_func marshal_mapform( PyObject* input );
3546 void cleanup_mapform( void );
3547 PLPointer marshal_PLPointer( PyObject* input, int isimg );
3548 void cleanup_PLPointer( void );
3549
3550
3551// This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3552
3553 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3554 {
3555 PyObject *pdata, *arglist, *result;
3556 PyArrayObject *tmp;
3557
3558 // the data argument is acutally a pointer to a python object
3559 pdata = (PyObject *) data;
3560 if ( data == NULL )
3561 {
3562 pdata = Py_None;
3563 }
3564 if ( python_pltr ) // if not something is terribly wrong
3565 { // hold a reference to the data object
3566 Py_XINCREF( pdata );
3567 // grab the Global Interpreter Lock to be sure threads don't mess us up
3569 // build the argument list
3570#ifdef PL_DOUBLE
3571 arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3572#else
3573 arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3574#endif
3575 if ( arglist == NULL )
3576 {
3577 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3578 *tx = *ty = 0;
3579 return;
3580 }
3581 // call the python function
3582 result = PyEval_CallObject( python_pltr, arglist );
3583 // release the argument list
3584 Py_CLEAR( arglist );
3585 // check and unpack the result
3586 if ( result == NULL )
3587 {
3588 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3589 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
3590 *tx = *ty = 0;
3591 }
3592 else
3593 {
3594 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3595 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3596 {
3597 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3598 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3599 *tx = *ty = 0;
3600 }
3601 else
3602 {
3603 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3604 *tx = t[0];
3605 *ty = t[1];
3606 Py_CLEAR( tmp );
3607 }
3608 }
3609 // release the result
3610 Py_CLEAR( result );
3611 // release the global interpreter lock
3613 }
3614 }
3615
3617 {
3618 PyObject *pdata, *arglist, *result;
3619 PLFLT fresult = 0.0;
3620
3621 // the data argument is acutally a pointer to a python object
3622 pdata = (PyObject *) data;
3623 if ( python_f2eval ) // if not something is terribly wrong
3624 { // hold a reference to the data object
3625 Py_XINCREF( pdata );
3626 // grab the Global Interpreter Lock to be sure threads don't mess us up
3628 // build the argument list
3629 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3630 // call the python function
3631 result = PyEval_CallObject( python_f2eval, arglist );
3632 // release the argument list
3633 Py_CLEAR( arglist );
3634 // check and unpack the result
3635 if ( !PyFloat_Check( result ) )
3636 {
3637 fprintf( stderr, "f2eval callback must return a float\n" );
3638 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3639 }
3640 else
3641 {
3642 // should I test the type here?
3643 fresult = (PLFLT) PyFloat_AsDouble( result );
3644 }
3645 // release the result
3646 Py_CLEAR( result );
3647 // release the global interpreter lock
3649 }
3650 return fresult;
3651 }
3652
3653 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
3654 {
3655 PyObject *pdata, *arglist, *result, *unicode_string;
3656 char *pystring;
3657
3658 // the data argument is acutally a pointer to a python object
3659 if ( data )
3660 pdata = (PyObject *) data;
3661 else
3662 pdata = Py_None;
3663 if ( python_label ) // if not something is terribly wrong
3664 { // hold a reference to the data object
3665 Py_XINCREF( pdata );
3666 // grab the Global Interpreter Lock to be sure threads don't mess us up
3668 // build the argument list
3669#ifdef PL_DOUBLE
3670 arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
3671#else
3672 arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
3673#endif
3674 // call the python function
3675 result = PyEval_CallObject( python_label, arglist );
3676 // release the argument list
3677 //Py_CLEAR(arglist);
3678 // check and unpack the result
3679 if ( result == NULL )
3680 {
3681 fprintf( stderr, "label callback failed with 3 arguments\n" );
3682 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
3683 }
3684 else if ( PyString_Check( result ) )
3685 {
3686 // should I test the type here?
3687 pystring = PyString_AsString( result );
3688 strncpy( string, pystring, len );
3689 }
3690 else if ( PyUnicode_Check( result ) )
3691 {
3692 // unicode_string is never freed? memory leak here?
3693 unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
3694 pystring = PyBytes_AS_STRING( unicode_string );
3695 // len may be different then the byte string length w/ unicode?
3696 strncpy( string, pystring, len );
3697 }
3698 else
3699 {
3700 fprintf( stderr, "label callback must return a string\n" );
3701 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
3702 }
3703 // release the result
3704 Py_CLEAR( result );
3705 // release the global interpreter lock
3707 }
3708 }
3709
3710 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
3711 {
3712 PyObject *px, *py, *pdata, *arglist, *result;
3713 npy_intp n;
3714 n = 1;
3715
3716 // the data argument is acutally a pointer to a python object
3717 pdata = (PyObject *) data;
3718 if ( data == NULL )
3719 {
3720 pdata = Py_None;
3721 }
3722 if ( python_ct ) // if not something is terribly wrong
3723 { // hold a reference to the data object
3724 Py_XINCREF( pdata );
3725 // grab the Global Interpreter Lock to be sure threads don't mess us up
3727 // build the argument list
3728 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
3729 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
3730 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
3731 // call the python function
3732 result = PyEval_CallObject( python_ct, arglist );
3733 // release the argument list
3734 Py_CLEAR( arglist );
3735 Py_CLEAR( px );
3736 Py_CLEAR( py );
3737 Py_CLEAR( pdata );
3738 // check and unpack the result
3739 if ( result == NULL )
3740 {
3741 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
3742 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
3743 }
3744 // release the result
3745 Py_CLEAR( result );
3746 // release the global interpreter lock
3748 }
3749 }
3750
3752 {
3753 PyObject *px, *py, *arglist, *result;
3754 // PyArrayObject *tmpx, *tmpy;
3755// PLFLT *xx, *yy;
3756// PLINT i;
3757 npy_intp nn;
3758 nn = n;
3759
3760 if ( python_mapform ) // if not something is terribly wrong
3761 { // grab the Global Interpreter Lock to be sure threads don't mess us up
3763 // build the argument list
3764#ifdef PL_HAVE_PTHREAD
3765 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
3766 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
3767#else
3768 px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
3769 py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
3770#endif
3771 arglist = Py_BuildValue( "(iOO)", n, px, py );
3772 // call the python function
3773 result = PyEval_CallObject( python_mapform, arglist );
3774 // release the argument list
3775 Py_CLEAR( arglist );
3776 Py_CLEAR( px );
3777 Py_CLEAR( py );
3778 // check and unpack the result
3779 if ( result == NULL )
3780 {
3781 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
3782 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
3783 }
3784 // release the result
3785 Py_CLEAR( result );
3786 // release the global interpreter lock
3788 }
3789 }
3790
3791// marshal the pltr function pointer argument
3792 pltr_func marshal_pltr( PyObject* input )
3793 {
3794 pltr_func result = do_pltr_callback;
3795 PyObject * rep = PyObject_Repr( input );
3796 if ( rep )
3797 {
3798 // Memory leaks here? str and uni_str are not freed?
3799 char* str;
3800 if ( PyUnicode_Check( rep ) )
3801 {
3802 PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
3803 str = PyBytes_AS_STRING( uni_str );
3804 }
3805 else
3806 {
3807 str = PyString_AsString( rep );
3808 }
3809 if ( strstr( str, "function pltr0" ) != 0 )
3810 {
3811 result = pltr0;
3812 pltr_type = CB_0;
3813 python_pltr = NULL;
3814 }
3815 else if ( strstr( str, "function pltr1" ) != 0 )
3816 {
3817 result = pltr1;
3818 pltr_type = CB_1;
3819 python_pltr = NULL;
3820 }
3821 else if ( strstr( str, "function pltr2" ) != 0 )
3822 {
3823 result = pltr2;
3824 pltr_type = CB_2;
3825 python_pltr = NULL;
3826 }
3827 else
3828 {
3829 python_pltr = input;
3831 Py_XINCREF( input );
3832 }
3833 Py_CLEAR( rep );
3834 }
3835 else
3836 {
3837 python_pltr = input;
3839 Py_XINCREF( input );
3840 }
3841 return result;
3842 }
3843
3844 void cleanup_pltr( void )
3845 {
3846 Py_CLEAR( python_pltr );
3847 python_pltr = 0;
3848 }
3849
3850// marshal the ct function pointer argument
3851 ct_func marshal_ct( PyObject* input )
3852 {
3853 ct_func result = do_ct_callback;
3854 python_ct = input;
3855 Py_XINCREF( input );
3856 return result;
3857 }
3858
3859 void cleanup_ct( void )
3860 {
3861 Py_CLEAR( python_ct );
3862 python_ct = 0;
3863 }
3864
3865// marshal the mapform function pointer argument
3867 {
3869 python_mapform = input;
3870 Py_XINCREF( input );
3871 return result;
3872 }
3873
3874 void cleanup_mapform( void )
3875 {
3876 Py_CLEAR( python_mapform );
3877 python_mapform = 0;
3878 }
3879
3880 PLPointer marshal_PLPointer( PyObject* input, int isimg )
3881 {
3882 PLPointer result = NULL;
3883 switch ( pltr_type )
3884 {
3885 case CB_0:
3886 break;
3887 case CB_1:
3888 if ( input != Py_None )
3889 result = marshal_PLcGrid1( input, isimg );
3890 break;
3891 case CB_2:
3892 if ( input != Py_None )
3893 result = marshal_PLcGrid2( input, isimg );
3894 break;
3895 case CB_Python:
3896 Py_XINCREF( input );
3897 result = (PLPointer *) input;
3898 break;
3899 default:
3900 fprintf( stderr, "pltr_type is invalid\n" );
3901 }
3902 return result;
3903 }
3904
3906 {
3907 switch ( pltr_type )
3908 {
3909 case CB_0:
3910 break;
3911 case CB_1:
3913 break;
3914 case CB_2:
3916 break;
3917 case CB_Python:
3918 Py_CLEAR( python_pltr );
3919 break;
3920 default:
3921 fprintf( stderr, "pltr_type is invalid\n" );
3922 }
3923 python_pltr = 0;
3924 pltr_type = CB_0;
3925 }
3926
3927
3928
3929SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3930 PyObject *resultobj = 0;
3931 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3932 int arg2 ;
3933 void *argp1 = 0 ;
3934 int res1 = 0 ;
3935 int val2 ;
3936 int ecode2 = 0 ;
3937 PyObject *swig_obj[2] ;
3938
3939 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_type_set", 2, 2, swig_obj)) SWIG_fail;
3940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3941 if (!SWIG_IsOK(res1)) {
3942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3943 }
3944 arg1 = (PLGraphicsIn *)(argp1);
3945 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
3946 if (!SWIG_IsOK(ecode2)) {
3947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
3948 }
3949 arg2 = (int)(val2);
3950 if (arg1) (arg1)->type = arg2;
3951 resultobj = SWIG_Py_Void();
3952 return resultobj;
3953fail:
3954 return NULL;
3955}
3956
3957
3958SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3959 PyObject *resultobj = 0;
3960 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3961 void *argp1 = 0 ;
3962 int res1 = 0 ;
3963 PyObject *swig_obj[1] ;
3964 int result;
3965
3966 if (!args) SWIG_fail;
3967 swig_obj[0] = args;
3968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3969 if (!SWIG_IsOK(res1)) {
3970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3971 }
3972 arg1 = (PLGraphicsIn *)(argp1);
3973 result = (int) ((arg1)->type);
3974 resultobj = SWIG_From_int((int)(result));
3975 return resultobj;
3976fail:
3977 return NULL;
3978}
3979
3980
3981SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3982 PyObject *resultobj = 0;
3983 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
3984 unsigned int arg2 ;
3985 void *argp1 = 0 ;
3986 int res1 = 0 ;
3987 unsigned int val2 ;
3988 int ecode2 = 0 ;
3989 PyObject *swig_obj[2] ;
3990
3991 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_state_set", 2, 2, swig_obj)) SWIG_fail;
3992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
3993 if (!SWIG_IsOK(res1)) {
3994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
3995 }
3996 arg1 = (PLGraphicsIn *)(argp1);
3997 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
3998 if (!SWIG_IsOK(ecode2)) {
3999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4000 }
4001 arg2 = (unsigned int)(val2);
4002 if (arg1) (arg1)->state = arg2;
4003 resultobj = SWIG_Py_Void();
4004 return resultobj;
4005fail:
4006 return NULL;
4007}
4008
4009
4010SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4011 PyObject *resultobj = 0;
4012 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4013 void *argp1 = 0 ;
4014 int res1 = 0 ;
4015 PyObject *swig_obj[1] ;
4016 unsigned int result;
4017
4018 if (!args) SWIG_fail;
4019 swig_obj[0] = args;
4020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4021 if (!SWIG_IsOK(res1)) {
4022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4023 }
4024 arg1 = (PLGraphicsIn *)(argp1);
4025 result = (unsigned int) ((arg1)->state);
4026 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4027 return resultobj;
4028fail:
4029 return NULL;
4030}
4031
4032
4033SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4034 PyObject *resultobj = 0;
4035 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4036 unsigned int arg2 ;
4037 void *argp1 = 0 ;
4038 int res1 = 0 ;
4039 unsigned int val2 ;
4040 int ecode2 = 0 ;
4041 PyObject *swig_obj[2] ;
4042
4043 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_keysym_set", 2, 2, swig_obj)) SWIG_fail;
4044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4045 if (!SWIG_IsOK(res1)) {
4046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4047 }
4048 arg1 = (PLGraphicsIn *)(argp1);
4049 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4050 if (!SWIG_IsOK(ecode2)) {
4051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4052 }
4053 arg2 = (unsigned int)(val2);
4054 if (arg1) (arg1)->keysym = arg2;
4055 resultobj = SWIG_Py_Void();
4056 return resultobj;
4057fail:
4058 return NULL;
4059}
4060
4061
4062SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4063 PyObject *resultobj = 0;
4064 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4065 void *argp1 = 0 ;
4066 int res1 = 0 ;
4067 PyObject *swig_obj[1] ;
4068 unsigned int result;
4069
4070 if (!args) SWIG_fail;
4071 swig_obj[0] = args;
4072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4073 if (!SWIG_IsOK(res1)) {
4074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4075 }
4076 arg1 = (PLGraphicsIn *)(argp1);
4077 result = (unsigned int) ((arg1)->keysym);
4078 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4079 return resultobj;
4080fail:
4081 return NULL;
4082}
4083
4084
4085SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4086 PyObject *resultobj = 0;
4087 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4088 unsigned int arg2 ;
4089 void *argp1 = 0 ;
4090 int res1 = 0 ;
4091 unsigned int val2 ;
4092 int ecode2 = 0 ;
4093 PyObject *swig_obj[2] ;
4094
4095 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_button_set", 2, 2, swig_obj)) SWIG_fail;
4096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4097 if (!SWIG_IsOK(res1)) {
4098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4099 }
4100 arg1 = (PLGraphicsIn *)(argp1);
4101 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4102 if (!SWIG_IsOK(ecode2)) {
4103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4104 }
4105 arg2 = (unsigned int)(val2);
4106 if (arg1) (arg1)->button = arg2;
4107 resultobj = SWIG_Py_Void();
4108 return resultobj;
4109fail:
4110 return NULL;
4111}
4112
4113
4114SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4115 PyObject *resultobj = 0;
4116 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4117 void *argp1 = 0 ;
4118 int res1 = 0 ;
4119 PyObject *swig_obj[1] ;
4120 unsigned int result;
4121
4122 if (!args) SWIG_fail;
4123 swig_obj[0] = args;
4124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4125 if (!SWIG_IsOK(res1)) {
4126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4127 }
4128 arg1 = (PLGraphicsIn *)(argp1);
4129 result = (unsigned int) ((arg1)->button);
4130 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4131 return resultobj;
4132fail:
4133 return NULL;
4134}
4135
4136
4137SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4138 PyObject *resultobj = 0;
4139 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4140 PLINT arg2 ;
4141 void *argp1 = 0 ;
4142 int res1 = 0 ;
4143 int val2 ;
4144 int ecode2 = 0 ;
4145 PyObject *swig_obj[2] ;
4146
4147 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_subwindow_set", 2, 2, swig_obj)) SWIG_fail;
4148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4149 if (!SWIG_IsOK(res1)) {
4150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4151 }
4152 arg1 = (PLGraphicsIn *)(argp1);
4153 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4154 if (!SWIG_IsOK(ecode2)) {
4155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4156 }
4157 arg2 = (PLINT)(val2);
4158 if (arg1) (arg1)->subwindow = arg2;
4159 resultobj = SWIG_Py_Void();
4160 return resultobj;
4161fail:
4162 return NULL;
4163}
4164
4165
4166SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4167 PyObject *resultobj = 0;
4168 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4169 void *argp1 = 0 ;
4170 int res1 = 0 ;
4171 PyObject *swig_obj[1] ;
4172 PLINT result;
4173
4174 if (!args) SWIG_fail;
4175 swig_obj[0] = args;
4176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4177 if (!SWIG_IsOK(res1)) {
4178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4179 }
4180 arg1 = (PLGraphicsIn *)(argp1);
4181 result = (PLINT) ((arg1)->subwindow);
4182 resultobj = SWIG_From_int((int)(result));
4183 return resultobj;
4184fail:
4185 return NULL;
4186}
4187
4188
4189SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4190 PyObject *resultobj = 0;
4191 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4192 char *arg2 ;
4193 void *argp1 = 0 ;
4194 int res1 = 0 ;
4195 char temp2[16] ;
4196 int res2 ;
4197 PyObject *swig_obj[2] ;
4198
4199 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_string_set", 2, 2, swig_obj)) SWIG_fail;
4200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4201 if (!SWIG_IsOK(res1)) {
4202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4203 }
4204 arg1 = (PLGraphicsIn *)(argp1);
4205 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 16);
4206 if (!SWIG_IsOK(res2)) {
4207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4208 }
4209 arg2 = (char *)(temp2);
4210 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4211 else memset(arg1->string,0,16*sizeof(char));
4212 resultobj = SWIG_Py_Void();
4213 return resultobj;
4214fail:
4215 return NULL;
4216}
4217
4218
4219SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4220 PyObject *resultobj = 0;
4221 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4222 void *argp1 = 0 ;
4223 int res1 = 0 ;
4224 PyObject *swig_obj[1] ;
4225 char *result = 0 ;
4226
4227 if (!args) SWIG_fail;
4228 swig_obj[0] = args;
4229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4230 if (!SWIG_IsOK(res1)) {
4231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4232 }
4233 arg1 = (PLGraphicsIn *)(argp1);
4234 result = (char *)(char *) ((arg1)->string);
4235 {
4236 size_t size = SWIG_strnlen(result, 16);
4237
4238
4239
4240 resultobj = SWIG_FromCharPtrAndSize(result, size);
4241 }
4242 return resultobj;
4243fail:
4244 return NULL;
4245}
4246
4247
4248SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4249 PyObject *resultobj = 0;
4250 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4251 int arg2 ;
4252 void *argp1 = 0 ;
4253 int res1 = 0 ;
4254 int val2 ;
4255 int ecode2 = 0 ;
4256 PyObject *swig_obj[2] ;
4257
4258 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pX_set", 2, 2, swig_obj)) SWIG_fail;
4259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4260 if (!SWIG_IsOK(res1)) {
4261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4262 }
4263 arg1 = (PLGraphicsIn *)(argp1);
4264 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4265 if (!SWIG_IsOK(ecode2)) {
4266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4267 }
4268 arg2 = (int)(val2);
4269 if (arg1) (arg1)->pX = arg2;
4270 resultobj = SWIG_Py_Void();
4271 return resultobj;
4272fail:
4273 return NULL;
4274}
4275
4276
4277SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4278 PyObject *resultobj = 0;
4279 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4280 void *argp1 = 0 ;
4281 int res1 = 0 ;
4282 PyObject *swig_obj[1] ;
4283 int result;
4284
4285 if (!args) SWIG_fail;
4286 swig_obj[0] = args;
4287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4288 if (!SWIG_IsOK(res1)) {
4289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4290 }
4291 arg1 = (PLGraphicsIn *)(argp1);
4292 result = (int) ((arg1)->pX);
4293 resultobj = SWIG_From_int((int)(result));
4294 return resultobj;
4295fail:
4296 return NULL;
4297}
4298
4299
4300SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4301 PyObject *resultobj = 0;
4302 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4303 int arg2 ;
4304 void *argp1 = 0 ;
4305 int res1 = 0 ;
4306 int val2 ;
4307 int ecode2 = 0 ;
4308 PyObject *swig_obj[2] ;
4309
4310 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pY_set", 2, 2, swig_obj)) SWIG_fail;
4311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4312 if (!SWIG_IsOK(res1)) {
4313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4314 }
4315 arg1 = (PLGraphicsIn *)(argp1);
4316 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4317 if (!SWIG_IsOK(ecode2)) {
4318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4319 }
4320 arg2 = (int)(val2);
4321 if (arg1) (arg1)->pY = arg2;
4322 resultobj = SWIG_Py_Void();
4323 return resultobj;
4324fail:
4325 return NULL;
4326}
4327
4328
4329SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4330 PyObject *resultobj = 0;
4331 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4332 void *argp1 = 0 ;
4333 int res1 = 0 ;
4334 PyObject *swig_obj[1] ;
4335 int result;
4336
4337 if (!args) SWIG_fail;
4338 swig_obj[0] = args;
4339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4340 if (!SWIG_IsOK(res1)) {
4341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4342 }
4343 arg1 = (PLGraphicsIn *)(argp1);
4344 result = (int) ((arg1)->pY);
4345 resultobj = SWIG_From_int((int)(result));
4346 return resultobj;
4347fail:
4348 return NULL;
4349}
4350
4351
4352SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4353 PyObject *resultobj = 0;
4354 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4355 PLFLT arg2 ;
4356 void *argp1 = 0 ;
4357 int res1 = 0 ;
4358 double val2 ;
4359 int ecode2 = 0 ;
4360 PyObject *swig_obj[2] ;
4361
4362 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dX_set", 2, 2, swig_obj)) SWIG_fail;
4363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4364 if (!SWIG_IsOK(res1)) {
4365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4366 }
4367 arg1 = (PLGraphicsIn *)(argp1);
4368 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4369 if (!SWIG_IsOK(ecode2)) {
4370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4371 }
4372 arg2 = (PLFLT)(val2);
4373 if (arg1) (arg1)->dX = arg2;
4374 resultobj = SWIG_Py_Void();
4375 return resultobj;
4376fail:
4377 return NULL;
4378}
4379
4380
4381SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4382 PyObject *resultobj = 0;
4383 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4384 void *argp1 = 0 ;
4385 int res1 = 0 ;
4386 PyObject *swig_obj[1] ;
4387 PLFLT result;
4388
4389 if (!args) SWIG_fail;
4390 swig_obj[0] = args;
4391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4392 if (!SWIG_IsOK(res1)) {
4393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4394 }
4395 arg1 = (PLGraphicsIn *)(argp1);
4396 result = (PLFLT) ((arg1)->dX);
4397 resultobj = SWIG_From_double((double)(result));
4398 return resultobj;
4399fail:
4400 return NULL;
4401}
4402
4403
4404SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4405 PyObject *resultobj = 0;
4406 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4407 PLFLT arg2 ;
4408 void *argp1 = 0 ;
4409 int res1 = 0 ;
4410 double val2 ;
4411 int ecode2 = 0 ;
4412 PyObject *swig_obj[2] ;
4413
4414 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dY_set", 2, 2, swig_obj)) SWIG_fail;
4415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4416 if (!SWIG_IsOK(res1)) {
4417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4418 }
4419 arg1 = (PLGraphicsIn *)(argp1);
4420 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4421 if (!SWIG_IsOK(ecode2)) {
4422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4423 }
4424 arg2 = (PLFLT)(val2);
4425 if (arg1) (arg1)->dY = arg2;
4426 resultobj = SWIG_Py_Void();
4427 return resultobj;
4428fail:
4429 return NULL;
4430}
4431
4432
4433SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4434 PyObject *resultobj = 0;
4435 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4436 void *argp1 = 0 ;
4437 int res1 = 0 ;
4438 PyObject *swig_obj[1] ;
4439 PLFLT result;
4440
4441 if (!args) SWIG_fail;
4442 swig_obj[0] = args;
4443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4444 if (!SWIG_IsOK(res1)) {
4445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4446 }
4447 arg1 = (PLGraphicsIn *)(argp1);
4448 result = (PLFLT) ((arg1)->dY);
4449 resultobj = SWIG_From_double((double)(result));
4450 return resultobj;
4451fail:
4452 return NULL;
4453}
4454
4455
4456SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4457 PyObject *resultobj = 0;
4458 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4459 PLFLT arg2 ;
4460 void *argp1 = 0 ;
4461 int res1 = 0 ;
4462 double val2 ;
4463 int ecode2 = 0 ;
4464 PyObject *swig_obj[2] ;
4465
4466 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wX_set", 2, 2, swig_obj)) SWIG_fail;
4467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4468 if (!SWIG_IsOK(res1)) {
4469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4470 }
4471 arg1 = (PLGraphicsIn *)(argp1);
4472 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4473 if (!SWIG_IsOK(ecode2)) {
4474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4475 }
4476 arg2 = (PLFLT)(val2);
4477 if (arg1) (arg1)->wX = arg2;
4478 resultobj = SWIG_Py_Void();
4479 return resultobj;
4480fail:
4481 return NULL;
4482}
4483
4484
4485SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4486 PyObject *resultobj = 0;
4487 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4488 void *argp1 = 0 ;
4489 int res1 = 0 ;
4490 PyObject *swig_obj[1] ;
4491 PLFLT result;
4492
4493 if (!args) SWIG_fail;
4494 swig_obj[0] = args;
4495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4496 if (!SWIG_IsOK(res1)) {
4497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4498 }
4499 arg1 = (PLGraphicsIn *)(argp1);
4500 result = (PLFLT) ((arg1)->wX);
4501 resultobj = SWIG_From_double((double)(result));
4502 return resultobj;
4503fail:
4504 return NULL;
4505}
4506
4507
4508SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4509 PyObject *resultobj = 0;
4510 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4511 PLFLT arg2 ;
4512 void *argp1 = 0 ;
4513 int res1 = 0 ;
4514 double val2 ;
4515 int ecode2 = 0 ;
4516 PyObject *swig_obj[2] ;
4517
4518 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wY_set", 2, 2, swig_obj)) SWIG_fail;
4519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4520 if (!SWIG_IsOK(res1)) {
4521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4522 }
4523 arg1 = (PLGraphicsIn *)(argp1);
4524 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4525 if (!SWIG_IsOK(ecode2)) {
4526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4527 }
4528 arg2 = (PLFLT)(val2);
4529 if (arg1) (arg1)->wY = arg2;
4530 resultobj = SWIG_Py_Void();
4531 return resultobj;
4532fail:
4533 return NULL;
4534}
4535
4536
4537SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4538 PyObject *resultobj = 0;
4539 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4540 void *argp1 = 0 ;
4541 int res1 = 0 ;
4542 PyObject *swig_obj[1] ;
4543 PLFLT result;
4544
4545 if (!args) SWIG_fail;
4546 swig_obj[0] = args;
4547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4548 if (!SWIG_IsOK(res1)) {
4549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4550 }
4551 arg1 = (PLGraphicsIn *)(argp1);
4552 result = (PLFLT) ((arg1)->wY);
4553 resultobj = SWIG_From_double((double)(result));
4554 return resultobj;
4555fail:
4556 return NULL;
4557}
4558
4559
4560SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4561 PyObject *resultobj = 0;
4562 PLGraphicsIn *result = 0 ;
4563
4564 if (!SWIG_Python_UnpackTuple(args, "new_PLGraphicsIn", 0, 0, 0)) SWIG_fail;
4565 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4567 return resultobj;
4568fail:
4569 return NULL;
4570}
4571
4572
4573SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4574 PyObject *resultobj = 0;
4575 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4576 void *argp1 = 0 ;
4577 int res1 = 0 ;
4578 PyObject *swig_obj[1] ;
4579
4580 if (!args) SWIG_fail;
4581 swig_obj[0] = args;
4582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4583 if (!SWIG_IsOK(res1)) {
4584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4585 }
4586 arg1 = (PLGraphicsIn *)(argp1);
4587 free((char *) arg1);
4588 resultobj = SWIG_Py_Void();
4589 return resultobj;
4590fail:
4591 return NULL;
4592}
4593
4594
4595SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4596 PyObject *obj;
4597 if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
4599 return SWIG_Py_Void();
4600}
4601
4602SWIGINTERN PyObject *PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4603 return SWIG_Python_InitShadowInstance(args);
4604}
4605
4606SWIGINTERN PyObject *_wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4607 PyObject *resultobj = 0;
4608 PLINT arg1 ;
4609 int val1 ;
4610 int ecode1 = 0 ;
4611 PyObject *swig_obj[1] ;
4612
4613 if (!args) SWIG_fail;
4614 swig_obj[0] = args;
4615 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4616 if (!SWIG_IsOK(ecode1)) {
4617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4618 }
4619 arg1 = (PLINT)(val1);
4620 plsxwin(arg1);
4621 resultobj = SWIG_Py_Void();
4622 return resultobj;
4623fail:
4624 return NULL;
4625}
4626
4627
4628SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4629 PyObject *resultobj = 0;
4630 PLINT arg1 ;
4631 PLINT arg2 ;
4632 int val1 ;
4633 int ecode1 = 0 ;
4634 int val2 ;
4635 int ecode2 = 0 ;
4636 PyObject *swig_obj[2] ;
4637
4638 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelformat", 2, 2, swig_obj)) SWIG_fail;
4639 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4640 if (!SWIG_IsOK(ecode1)) {
4641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4642 }
4643 arg1 = (PLINT)(val1);
4644 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4645 if (!SWIG_IsOK(ecode2)) {
4646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4647 }
4648 arg2 = (PLINT)(val2);
4649 pl_setcontlabelformat(arg1,arg2);
4650 resultobj = SWIG_Py_Void();
4651 return resultobj;
4652fail:
4653 return NULL;
4654}
4655
4656
4657SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4658 PyObject *resultobj = 0;
4659 PLFLT arg1 ;
4660 PLFLT arg2 ;
4661 PLFLT arg3 ;
4662 PLINT arg4 ;
4663 double val1 ;
4664 int ecode1 = 0 ;
4665 double val2 ;
4666 int ecode2 = 0 ;
4667 double val3 ;
4668 int ecode3 = 0 ;
4669 int val4 ;
4670 int ecode4 = 0 ;
4671 PyObject *swig_obj[4] ;
4672
4673 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelparam", 4, 4, swig_obj)) SWIG_fail;
4674 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4675 if (!SWIG_IsOK(ecode1)) {
4676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
4677 }
4678 arg1 = (PLFLT)(val1);
4679 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4680 if (!SWIG_IsOK(ecode2)) {
4681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
4682 }
4683 arg2 = (PLFLT)(val2);
4684 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
4685 if (!SWIG_IsOK(ecode3)) {
4686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
4687 }
4688 arg3 = (PLFLT)(val3);
4689 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
4690 if (!SWIG_IsOK(ecode4)) {
4691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
4692 }
4693 arg4 = (PLINT)(val4);
4694 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
4695 resultobj = SWIG_Py_Void();
4696 return resultobj;
4697fail:
4698 return NULL;
4699}
4700
4701
4702SWIGINTERN PyObject *_wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4703 PyObject *resultobj = 0;
4704 PLINT arg1 ;
4705 int val1 ;
4706 int ecode1 = 0 ;
4707 PyObject *swig_obj[1] ;
4708
4709 if (!args) SWIG_fail;
4710 swig_obj[0] = args;
4711 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4712 if (!SWIG_IsOK(ecode1)) {
4713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
4714 }
4715 arg1 = (PLINT)(val1);
4716 pladv(arg1);
4717 resultobj = SWIG_Py_Void();
4718 return resultobj;
4719fail:
4720 return NULL;
4721}
4722
4723
4724SWIGINTERN PyObject *_wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4725 PyObject *resultobj = 0;
4726 PLFLT arg1 ;
4727 PLFLT arg2 ;
4728 PLFLT arg3 ;
4729 PLFLT arg4 ;
4730 PLFLT arg5 ;
4731 PLFLT arg6 ;
4732 PLFLT arg7 ;
4733 PLBOOL arg8 ;
4734 double val1 ;
4735 int ecode1 = 0 ;
4736 double val2 ;
4737 int ecode2 = 0 ;
4738 double val3 ;
4739 int ecode3 = 0 ;
4740 double val4 ;
4741 int ecode4 = 0 ;
4742 double val5 ;
4743 int ecode5 = 0 ;
4744 double val6 ;
4745 int ecode6 = 0 ;
4746 double val7 ;
4747 int ecode7 = 0 ;
4748 int val8 ;
4749 int ecode8 = 0 ;
4750 PyObject *swig_obj[8] ;
4751
4752 if (!SWIG_Python_UnpackTuple(args, "plarc", 8, 8, swig_obj)) SWIG_fail;
4753 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4754 if (!SWIG_IsOK(ecode1)) {
4755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
4756 }
4757 arg1 = (PLFLT)(val1);
4758 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4759 if (!SWIG_IsOK(ecode2)) {
4760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
4761 }
4762 arg2 = (PLFLT)(val2);
4763 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
4764 if (!SWIG_IsOK(ecode3)) {
4765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
4766 }
4767 arg3 = (PLFLT)(val3);
4768 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
4769 if (!SWIG_IsOK(ecode4)) {
4770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
4771 }
4772 arg4 = (PLFLT)(val4);
4773 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
4774 if (!SWIG_IsOK(ecode5)) {
4775 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
4776 }
4777 arg5 = (PLFLT)(val5);
4778 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
4779 if (!SWIG_IsOK(ecode6)) {
4780 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
4781 }
4782 arg6 = (PLFLT)(val6);
4783 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
4784 if (!SWIG_IsOK(ecode7)) {
4785 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
4786 }
4787 arg7 = (PLFLT)(val7);
4788 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
4789 if (!SWIG_IsOK(ecode8)) {
4790 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
4791 }
4792 arg8 = (PLBOOL)(val8);
4793 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4794 resultobj = SWIG_Py_Void();
4795 return resultobj;
4796fail:
4797 return NULL;
4798}
4799
4800
4801SWIGINTERN PyObject *_wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4802 PyObject *resultobj = 0;
4803 PLFLT arg1 ;
4804 PLFLT arg2 ;
4805 char *arg3 = (char *) 0 ;
4806 PLFLT arg4 ;
4807 PLINT arg5 ;
4808 char *arg6 = (char *) 0 ;
4809 PLFLT arg7 ;
4810 PLINT arg8 ;
4811 double val1 ;
4812 int ecode1 = 0 ;
4813 double val2 ;
4814 int ecode2 = 0 ;
4815 int res3 ;
4816 char *buf3 = 0 ;
4817 int alloc3 = 0 ;
4818 double val4 ;
4819 int ecode4 = 0 ;
4820 int val5 ;
4821 int ecode5 = 0 ;
4822 int res6 ;
4823 char *buf6 = 0 ;
4824 int alloc6 = 0 ;
4825 double val7 ;
4826 int ecode7 = 0 ;
4827 int val8 ;
4828 int ecode8 = 0 ;
4829 PyObject *swig_obj[8] ;
4830
4831 if (!SWIG_Python_UnpackTuple(args, "plaxes", 8, 8, swig_obj)) SWIG_fail;
4832 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4833 if (!SWIG_IsOK(ecode1)) {
4834 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
4835 }
4836 arg1 = (PLFLT)(val1);
4837 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4838 if (!SWIG_IsOK(ecode2)) {
4839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
4840 }
4841 arg2 = (PLFLT)(val2);
4842 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
4843 if (!SWIG_IsOK(res3)) {
4844 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
4845 }
4846 arg3 = (char *)(buf3);
4847 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
4848 if (!SWIG_IsOK(ecode4)) {
4849 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
4850 }
4851 arg4 = (PLFLT)(val4);
4852 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
4853 if (!SWIG_IsOK(ecode5)) {
4854 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
4855 }
4856 arg5 = (PLINT)(val5);
4857 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
4858 if (!SWIG_IsOK(res6)) {
4859 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
4860 }
4861 arg6 = (char *)(buf6);
4862 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
4863 if (!SWIG_IsOK(ecode7)) {
4864 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
4865 }
4866 arg7 = (PLFLT)(val7);
4867 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
4868 if (!SWIG_IsOK(ecode8)) {
4869 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
4870 }
4871 arg8 = (PLINT)(val8);
4872 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
4873 resultobj = SWIG_Py_Void();
4874 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4875 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
4876 return resultobj;
4877fail:
4878 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4879 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
4880 return NULL;
4881}
4882
4883
4884SWIGINTERN PyObject *_wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4885 PyObject *resultobj = 0;
4886 PLINT arg1 ;
4887 PLFLT *arg2 = (PLFLT *) 0 ;
4888 PLFLT *arg3 = (PLFLT *) 0 ;
4889 PLINT arg4 ;
4890 PyArrayObject *tmp1 = NULL ;
4891 PyArrayObject *tmp3 = NULL ;
4892 int val4 ;
4893 int ecode4 = 0 ;
4894 PyObject *swig_obj[3] ;
4895
4896 if (!SWIG_Python_UnpackTuple(args, "plbin", 3, 3, swig_obj)) SWIG_fail;
4897 {
4898 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
4899 if ( tmp1 == NULL )
4900 return NULL;
4901 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
4902 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
4903 }
4904 {
4905 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
4906 if ( tmp3 == NULL )
4907 return NULL;
4908 if ( PyArray_DIMS( tmp3 )[0] != Alen )
4909 {
4910 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
4911 return NULL;
4912 }
4913 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
4914 }
4915 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
4916 if (!SWIG_IsOK(ecode4)) {
4917 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
4918 }
4919 arg4 = (PLINT)(val4);
4920 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
4921 resultobj = SWIG_Py_Void();
4922 {
4923 Py_CLEAR( tmp1 );
4924 }
4925 {
4926 Py_CLEAR( tmp3 );
4927 }
4928 return resultobj;
4929fail:
4930 {
4931 Py_CLEAR( tmp1 );
4932 }
4933 {
4934 Py_CLEAR( tmp3 );
4935 }
4936 return NULL;
4937}
4938
4939
4940SWIGINTERN PyObject *_wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4941 PyObject *resultobj = 0;
4942 PLINT *arg1 = (PLINT *) 0 ;
4943 PLINT *arg2 = (PLINT *) 0 ;
4944 PLINT *arg3 = (PLINT *) 0 ;
4945 PLINT *arg4 = (PLINT *) 0 ;
4946 PLINT *arg5 = (PLINT *) 0 ;
4947 PLFLT *arg6 = (PLFLT *) 0 ;
4948 PLFLT arg7 ;
4949 PLINT temp1 ;
4950 int res1 = SWIG_TMPOBJ ;
4951 PLINT temp2 ;
4952 int res2 = SWIG_TMPOBJ ;
4953 PLINT temp3 ;
4954 int res3 = SWIG_TMPOBJ ;
4955 PLINT temp4 ;
4956 int res4 = SWIG_TMPOBJ ;
4957 PLINT temp5 ;
4958 int res5 = SWIG_TMPOBJ ;
4959 PLFLT temp6 ;
4960 int res6 = SWIG_TMPOBJ ;
4961 double val7 ;
4962 int ecode7 = 0 ;
4963 PyObject *swig_obj[1] ;
4964
4965 arg1 = &temp1;
4966 arg2 = &temp2;
4967 arg3 = &temp3;
4968 arg4 = &temp4;
4969 arg5 = &temp5;
4970 arg6 = &temp6;
4971 if (!args) SWIG_fail;
4972 swig_obj[0] = args;
4973 ecode7 = SWIG_AsVal_double(swig_obj[0], &val7);
4974 if (!SWIG_IsOK(ecode7)) {
4975 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
4976 }
4977 arg7 = (PLFLT)(val7);
4978 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
4979 resultobj = SWIG_Py_Void();
4980 if (SWIG_IsTmpObj(res1)) {
4981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
4982 } else {
4983 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
4985 }
4986 if (SWIG_IsTmpObj(res2)) {
4987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
4988 } else {
4989 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
4991 }
4992 if (SWIG_IsTmpObj(res3)) {
4993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
4994 } else {
4995 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
4997 }
4998 if (SWIG_IsTmpObj(res4)) {
4999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5000 } else {
5001 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5003 }
5004 if (SWIG_IsTmpObj(res5)) {
5005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5006 } else {
5007 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5009 }
5010 if (SWIG_IsTmpObj(res6)) {
5011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5012 } else {
5013 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5015 }
5016 return resultobj;
5017fail:
5018 return NULL;
5019}
5020
5021
5022SWIGINTERN PyObject *_wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5023 PyObject *resultobj = 0;
5024
5025 if (!SWIG_Python_UnpackTuple(args, "plbop", 0, 0, 0)) SWIG_fail;
5026 plbop();
5027 resultobj = SWIG_Py_Void();
5028 return resultobj;
5029fail:
5030 return NULL;
5031}
5032
5033
5034SWIGINTERN PyObject *_wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5035 PyObject *resultobj = 0;
5036 char *arg1 = (char *) 0 ;
5037 PLFLT arg2 ;
5038 PLINT arg3 ;
5039 char *arg4 = (char *) 0 ;
5040 PLFLT arg5 ;
5041 PLINT arg6 ;
5042 int res1 ;
5043 char *buf1 = 0 ;
5044 int alloc1 = 0 ;
5045 double val2 ;
5046 int ecode2 = 0 ;
5047 int val3 ;
5048 int ecode3 = 0 ;
5049 int res4 ;
5050 char *buf4 = 0 ;
5051 int alloc4 = 0 ;
5052 double val5 ;
5053 int ecode5 = 0 ;
5054 int val6 ;
5055 int ecode6 = 0 ;
5056 PyObject *swig_obj[6] ;
5057
5058 if (!SWIG_Python_UnpackTuple(args, "plbox", 6, 6, swig_obj)) SWIG_fail;
5059 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5060 if (!SWIG_IsOK(res1)) {
5061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5062 }
5063 arg1 = (char *)(buf1);
5064 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5065 if (!SWIG_IsOK(ecode2)) {
5066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5067 }
5068 arg2 = (PLFLT)(val2);
5069 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5070 if (!SWIG_IsOK(ecode3)) {
5071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5072 }
5073 arg3 = (PLINT)(val3);
5074 res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
5075 if (!SWIG_IsOK(res4)) {
5076 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5077 }
5078 arg4 = (char *)(buf4);
5079 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5080 if (!SWIG_IsOK(ecode5)) {
5081 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5082 }
5083 arg5 = (PLFLT)(val5);
5084 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5085 if (!SWIG_IsOK(ecode6)) {
5086 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5087 }
5088 arg6 = (PLINT)(val6);
5089 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5090 resultobj = SWIG_Py_Void();
5091 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5092 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5093 return resultobj;
5094fail:
5095 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5096 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5097 return NULL;
5098}
5099
5100
5101SWIGINTERN PyObject *_wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5102 PyObject *resultobj = 0;
5103 char *arg1 = (char *) 0 ;
5104 char *arg2 = (char *) 0 ;
5105 PLFLT arg3 ;
5106 PLINT arg4 ;
5107 char *arg5 = (char *) 0 ;
5108 char *arg6 = (char *) 0 ;
5109 PLFLT arg7 ;
5110 PLINT arg8 ;
5111 char *arg9 = (char *) 0 ;
5112 char *arg10 = (char *) 0 ;
5113 PLFLT arg11 ;
5114 PLINT arg12 ;
5115 int res1 ;
5116 char *buf1 = 0 ;
5117 int alloc1 = 0 ;
5118 int res2 ;
5119 char *buf2 = 0 ;
5120 int alloc2 = 0 ;
5121 double val3 ;
5122 int ecode3 = 0 ;
5123 int val4 ;
5124 int ecode4 = 0 ;
5125 int res5 ;
5126 char *buf5 = 0 ;
5127 int alloc5 = 0 ;
5128 int res6 ;
5129 char *buf6 = 0 ;
5130 int alloc6 = 0 ;
5131 double val7 ;
5132 int ecode7 = 0 ;
5133 int val8 ;
5134 int ecode8 = 0 ;
5135 int res9 ;
5136 char *buf9 = 0 ;
5137 int alloc9 = 0 ;
5138 int res10 ;
5139 char *buf10 = 0 ;
5140 int alloc10 = 0 ;
5141 double val11 ;
5142 int ecode11 = 0 ;
5143 int val12 ;
5144 int ecode12 = 0 ;
5145 PyObject *swig_obj[12] ;
5146
5147 if (!SWIG_Python_UnpackTuple(args, "plbox3", 12, 12, swig_obj)) SWIG_fail;
5148 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5149 if (!SWIG_IsOK(res1)) {
5150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5151 }
5152 arg1 = (char *)(buf1);
5153 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
5154 if (!SWIG_IsOK(res2)) {
5155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5156 }
5157 arg2 = (char *)(buf2);
5158 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5159 if (!SWIG_IsOK(ecode3)) {
5160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5161 }
5162 arg3 = (PLFLT)(val3);
5163 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5164 if (!SWIG_IsOK(ecode4)) {
5165 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5166 }
5167 arg4 = (PLINT)(val4);
5168 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
5169 if (!SWIG_IsOK(res5)) {
5170 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5171 }
5172 arg5 = (char *)(buf5);
5173 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5174 if (!SWIG_IsOK(res6)) {
5175 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5176 }
5177 arg6 = (char *)(buf6);
5178 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5179 if (!SWIG_IsOK(ecode7)) {
5180 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5181 }
5182 arg7 = (PLFLT)(val7);
5183 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5184 if (!SWIG_IsOK(ecode8)) {
5185 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5186 }
5187 arg8 = (PLINT)(val8);
5188 res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
5189 if (!SWIG_IsOK(res9)) {
5190 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5191 }
5192 arg9 = (char *)(buf9);
5193 res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
5194 if (!SWIG_IsOK(res10)) {
5195 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5196 }
5197 arg10 = (char *)(buf10);
5198 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5199 if (!SWIG_IsOK(ecode11)) {
5200 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5201 }
5202 arg11 = (PLFLT)(val11);
5203 ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
5204 if (!SWIG_IsOK(ecode12)) {
5205 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5206 }
5207 arg12 = (PLINT)(val12);
5208 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);
5209 resultobj = SWIG_Py_Void();
5210 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5211 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5212 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5213 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5214 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5215 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5216 return resultobj;
5217fail:
5218 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5219 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5220 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5221 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5222 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5223 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5224 return NULL;
5225}
5226
5227
5228SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5229 PyObject *resultobj = 0;
5230 PLFLT arg1 ;
5231 PLFLT arg2 ;
5232 PLFLT *arg3 = (PLFLT *) 0 ;
5233 PLFLT *arg4 = (PLFLT *) 0 ;
5234 PLINT *arg5 = (PLINT *) 0 ;
5235 double val1 ;
5236 int ecode1 = 0 ;
5237 double val2 ;
5238 int ecode2 = 0 ;
5239 PLFLT temp3 ;
5240 int res3 = SWIG_TMPOBJ ;
5241 PLFLT temp4 ;
5242 int res4 = SWIG_TMPOBJ ;
5243 PLINT temp5 ;
5244 int res5 = SWIG_TMPOBJ ;
5245 PyObject *swig_obj[2] ;
5246
5247 arg3 = &temp3;
5248 arg4 = &temp4;
5249 arg5 = &temp5;
5250 if (!SWIG_Python_UnpackTuple(args, "plcalc_world", 2, 2, swig_obj)) SWIG_fail;
5251 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5252 if (!SWIG_IsOK(ecode1)) {
5253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5254 }
5255 arg1 = (PLFLT)(val1);
5256 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5257 if (!SWIG_IsOK(ecode2)) {
5258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5259 }
5260 arg2 = (PLFLT)(val2);
5261 plcalc_world(arg1,arg2,arg3,arg4,arg5);
5262 resultobj = SWIG_Py_Void();
5263 if (SWIG_IsTmpObj(res3)) {
5264 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5265 } else {
5266 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5267 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5268 }
5269 if (SWIG_IsTmpObj(res4)) {
5270 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5271 } else {
5272 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5274 }
5275 if (SWIG_IsTmpObj(res5)) {
5276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5277 } else {
5278 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5280 }
5281 return resultobj;
5282fail:
5283 return NULL;
5284}
5285
5286
5287SWIGINTERN PyObject *_wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5288 PyObject *resultobj = 0;
5289
5290 if (!SWIG_Python_UnpackTuple(args, "plclear", 0, 0, 0)) SWIG_fail;
5291 plclear();
5292 resultobj = SWIG_Py_Void();
5293 return resultobj;
5294fail:
5295 return NULL;
5296}
5297
5298
5299SWIGINTERN PyObject *_wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5300 PyObject *resultobj = 0;
5301 PLINT arg1 ;
5302 int val1 ;
5303 int ecode1 = 0 ;
5304 PyObject *swig_obj[1] ;
5305
5306 if (!args) SWIG_fail;
5307 swig_obj[0] = args;
5308 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5309 if (!SWIG_IsOK(ecode1)) {
5310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5311 }
5312 arg1 = (PLINT)(val1);
5313 plcol0(arg1);
5314 resultobj = SWIG_Py_Void();
5315 return resultobj;
5316fail:
5317 return NULL;
5318}
5319
5320
5321SWIGINTERN PyObject *_wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5322 PyObject *resultobj = 0;
5323 PLFLT arg1 ;
5324 double val1 ;
5325 int ecode1 = 0 ;
5326 PyObject *swig_obj[1] ;
5327
5328 if (!args) SWIG_fail;
5329 swig_obj[0] = args;
5330 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5331 if (!SWIG_IsOK(ecode1)) {
5332 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5333 }
5334 arg1 = (PLFLT)(val1);
5335 plcol1(arg1);
5336 resultobj = SWIG_Py_Void();
5337 return resultobj;
5338fail:
5339 return NULL;
5340}
5341
5342
5343SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5344 PyObject *resultobj = 0;
5345 PLFLT arg1 ;
5346 PLFLT arg2 ;
5347 PLFLT arg3 ;
5348 PLINT arg4 ;
5349 PLBOOL arg5 ;
5350 PLINT arg6 ;
5351 PLINT arg7 ;
5352 PLINT arg8 ;
5353 PLINT arg9 ;
5354 PLINT arg10 ;
5355 PLFLT arg11 ;
5356 double val1 ;
5357 int ecode1 = 0 ;
5358 double val2 ;
5359 int ecode2 = 0 ;
5360 double val3 ;
5361 int ecode3 = 0 ;
5362 int val4 ;
5363 int ecode4 = 0 ;
5364 int val5 ;
5365 int ecode5 = 0 ;
5366 int val6 ;
5367 int ecode6 = 0 ;
5368 int val7 ;
5369 int ecode7 = 0 ;
5370 int val8 ;
5371 int ecode8 = 0 ;
5372 int val9 ;
5373 int ecode9 = 0 ;
5374 int val10 ;
5375 int ecode10 = 0 ;
5376 double val11 ;
5377 int ecode11 = 0 ;
5378 PyObject *swig_obj[11] ;
5379
5380 if (!SWIG_Python_UnpackTuple(args, "plconfigtime", 11, 11, swig_obj)) SWIG_fail;
5381 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5382 if (!SWIG_IsOK(ecode1)) {
5383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5384 }
5385 arg1 = (PLFLT)(val1);
5386 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5387 if (!SWIG_IsOK(ecode2)) {
5388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5389 }
5390 arg2 = (PLFLT)(val2);
5391 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5392 if (!SWIG_IsOK(ecode3)) {
5393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5394 }
5395 arg3 = (PLFLT)(val3);
5396 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5397 if (!SWIG_IsOK(ecode4)) {
5398 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5399 }
5400 arg4 = (PLINT)(val4);
5401 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5402 if (!SWIG_IsOK(ecode5)) {
5403 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5404 }
5405 arg5 = (PLBOOL)(val5);
5406 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5407 if (!SWIG_IsOK(ecode6)) {
5408 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5409 }
5410 arg6 = (PLINT)(val6);
5411 ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
5412 if (!SWIG_IsOK(ecode7)) {
5413 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5414 }
5415 arg7 = (PLINT)(val7);
5416 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5417 if (!SWIG_IsOK(ecode8)) {
5418 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5419 }
5420 arg8 = (PLINT)(val8);
5421 ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
5422 if (!SWIG_IsOK(ecode9)) {
5423 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5424 }
5425 arg9 = (PLINT)(val9);
5426 ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
5427 if (!SWIG_IsOK(ecode10)) {
5428 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5429 }
5430 arg10 = (PLINT)(val10);
5431 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5432 if (!SWIG_IsOK(ecode11)) {
5433 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5434 }
5435 arg11 = (PLFLT)(val11);
5436 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5437 resultobj = SWIG_Py_Void();
5438 return resultobj;
5439fail:
5440 return NULL;
5441}
5442
5443
5444SWIGINTERN PyObject *_wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5445 PyObject *resultobj = 0;
5446 PLFLT **arg1 = (PLFLT **) 0 ;
5447 PLINT arg2 ;
5448 PLINT arg3 ;
5449 PLINT arg4 ;
5450 PLINT arg5 ;
5451 PLINT arg6 ;
5452 PLINT arg7 ;
5453 PLFLT *arg8 = (PLFLT *) 0 ;
5454 PLINT arg9 ;
5455 pltr_func arg10 = (pltr_func) 0 ;
5456 PLPointer arg11 = (PLPointer) 0 ;
5457 PyArrayObject *tmp1 = NULL ;
5458 int val4 ;
5459 int ecode4 = 0 ;
5460 int val5 ;
5461 int ecode5 = 0 ;
5462 int val6 ;
5463 int ecode6 = 0 ;
5464 int val7 ;
5465 int ecode7 = 0 ;
5466 PyArrayObject *tmp8 = NULL ;
5467 PyObject *swig_obj[8] ;
5468
5469 {
5470 python_pltr = 0;
5471 arg10 = NULL;
5472 }
5473 {
5474 arg11 = NULL;
5475 }
5476 if (!SWIG_Python_UnpackTuple(args, "plcont", 6, 8, swig_obj)) SWIG_fail;
5477 {
5478 int i, size;
5479 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
5480 if ( tmp1 == NULL )
5481 return NULL;
5482 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5483 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5484 size = arg3;
5485 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
5486 for ( i = 0; i < arg2; i++ )
5487 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5488 }
5489 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
5490 if (!SWIG_IsOK(ecode4)) {
5491 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5492 }
5493 arg4 = (PLINT)(val4);
5494 ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
5495 if (!SWIG_IsOK(ecode5)) {
5496 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5497 }
5498 arg5 = (PLINT)(val5);
5499 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
5500 if (!SWIG_IsOK(ecode6)) {
5501 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5502 }
5503 arg6 = (PLINT)(val6);
5504 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
5505 if (!SWIG_IsOK(ecode7)) {
5506 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5507 }
5508 arg7 = (PLINT)(val7);
5509 {
5510 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
5511 if ( tmp8 == NULL )
5512 return NULL;
5513 arg9 = PyArray_DIMS( tmp8 )[0];
5514 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5515 }
5516 if (swig_obj[6]) {
5517 {
5518 // it must be a callable or None
5519 if ( swig_obj[6] == Py_None )
5520 {
5521 arg10 = NULL;
5522 }
5523 else
5524 {
5525 if ( !PyCallable_Check( (PyObject *) swig_obj[6] ) )
5526 {
5527 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5528 return NULL;
5529 }
5530 arg10 = marshal_pltr( swig_obj[6] );
5531 }
5532 }
5533 }
5534 if (swig_obj[7]) {
5535 {
5536 if ( swig_obj[7] == Py_None )
5537 arg11 = NULL;
5538 else
5539 {
5540 arg11 = marshal_PLPointer( swig_obj[7], 0 );
5541 }
5542 }
5543 }
5544 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5545 resultobj = SWIG_Py_Void();
5546 {
5547 Py_CLEAR( tmp1 );
5548 free( arg1 );
5549 }
5550 {
5551 Py_CLEAR( tmp8 );
5552 }
5553 {
5554 cleanup_pltr();
5555 }
5556 {
5558 }
5559 return resultobj;
5560fail:
5561 {
5562 Py_CLEAR( tmp1 );
5563 free( arg1 );
5564 }
5565 {
5566 Py_CLEAR( tmp8 );
5567 }
5568 {
5569 cleanup_pltr();
5570 }
5571 {
5573 }
5574 return NULL;
5575}
5576
5577
5578SWIGINTERN PyObject *_wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5579 PyObject *resultobj = 0;
5580 PLINT arg1 ;
5581 PLINT arg2 ;
5582 PLINT arg3 ;
5583 PLINT arg4 ;
5584 PLINT arg5 ;
5585 PLFLT arg6 ;
5586 PLFLT *arg7 = (PLFLT *) 0 ;
5587 int val1 ;
5588 int ecode1 = 0 ;
5589 int val2 ;
5590 int ecode2 = 0 ;
5591 int val3 ;
5592 int ecode3 = 0 ;
5593 int val4 ;
5594 int ecode4 = 0 ;
5595 int val5 ;
5596 int ecode5 = 0 ;
5597 double val6 ;
5598 int ecode6 = 0 ;
5599 PLFLT temp7 ;
5600 int res7 = SWIG_TMPOBJ ;
5601 PyObject *swig_obj[6] ;
5602
5603 arg7 = &temp7;
5604 if (!SWIG_Python_UnpackTuple(args, "plctime", 6, 6, swig_obj)) SWIG_fail;
5605 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5606 if (!SWIG_IsOK(ecode1)) {
5607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
5608 }
5609 arg1 = (PLINT)(val1);
5610 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5611 if (!SWIG_IsOK(ecode2)) {
5612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
5613 }
5614 arg2 = (PLINT)(val2);
5615 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5616 if (!SWIG_IsOK(ecode3)) {
5617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
5618 }
5619 arg3 = (PLINT)(val3);
5620 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5621 if (!SWIG_IsOK(ecode4)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
5623 }
5624 arg4 = (PLINT)(val4);
5625 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5626 if (!SWIG_IsOK(ecode5)) {
5627 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
5628 }
5629 arg5 = (PLINT)(val5);
5630 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5631 if (!SWIG_IsOK(ecode6)) {
5632 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
5633 }
5634 arg6 = (PLFLT)(val6);
5635 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5636 resultobj = SWIG_Py_Void();
5637 if (SWIG_IsTmpObj(res7)) {
5638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
5639 } else {
5640 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
5642 }
5643 return resultobj;
5644fail:
5645 return NULL;
5646}
5647
5648
5649SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5650 PyObject *resultobj = 0;
5651 PLINT arg1 ;
5652 PLBOOL arg2 ;
5653 int val1 ;
5654 int ecode1 = 0 ;
5655 int val2 ;
5656 int ecode2 = 0 ;
5657 PyObject *swig_obj[2] ;
5658
5659 if (!SWIG_Python_UnpackTuple(args, "plcpstrm", 2, 2, swig_obj)) SWIG_fail;
5660 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5661 if (!SWIG_IsOK(ecode1)) {
5662 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
5663 }
5664 arg1 = (PLINT)(val1);
5665 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5666 if (!SWIG_IsOK(ecode2)) {
5667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
5668 }
5669 arg2 = (PLBOOL)(val2);
5670 plcpstrm(arg1,arg2);
5671 resultobj = SWIG_Py_Void();
5672 return resultobj;
5673fail:
5674 return NULL;
5675}
5676
5677
5678SWIGINTERN PyObject *_wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5679 PyObject *resultobj = 0;
5680
5681 if (!SWIG_Python_UnpackTuple(args, "plend", 0, 0, 0)) SWIG_fail;
5682 plend();
5683 resultobj = SWIG_Py_Void();
5684 return resultobj;
5685fail:
5686 return NULL;
5687}
5688
5689
5690SWIGINTERN PyObject *_wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5691 PyObject *resultobj = 0;
5692
5693 if (!SWIG_Python_UnpackTuple(args, "plend1", 0, 0, 0)) SWIG_fail;
5694 plend1();
5695 resultobj = SWIG_Py_Void();
5696 return resultobj;
5697fail:
5698 return NULL;
5699}
5700
5701
5702SWIGINTERN PyObject *_wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5703 PyObject *resultobj = 0;
5704 PLFLT arg1 ;
5705 PLFLT arg2 ;
5706 PLFLT arg3 ;
5707 PLFLT arg4 ;
5708 PLINT arg5 ;
5709 PLINT arg6 ;
5710 double val1 ;
5711 int ecode1 = 0 ;
5712 double val2 ;
5713 int ecode2 = 0 ;
5714 double val3 ;
5715 int ecode3 = 0 ;
5716 double val4 ;
5717 int ecode4 = 0 ;
5718 int val5 ;
5719 int ecode5 = 0 ;
5720 int val6 ;
5721 int ecode6 = 0 ;
5722 PyObject *swig_obj[6] ;
5723
5724 if (!SWIG_Python_UnpackTuple(args, "plenv", 6, 6, swig_obj)) SWIG_fail;
5725 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5726 if (!SWIG_IsOK(ecode1)) {
5727 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
5728 }
5729 arg1 = (PLFLT)(val1);
5730 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5731 if (!SWIG_IsOK(ecode2)) {
5732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
5733 }
5734 arg2 = (PLFLT)(val2);
5735 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5736 if (!SWIG_IsOK(ecode3)) {
5737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
5738 }
5739 arg3 = (PLFLT)(val3);
5740 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5741 if (!SWIG_IsOK(ecode4)) {
5742 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
5743 }
5744 arg4 = (PLFLT)(val4);
5745 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5746 if (!SWIG_IsOK(ecode5)) {
5747 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
5748 }
5749 arg5 = (PLINT)(val5);
5750 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5751 if (!SWIG_IsOK(ecode6)) {
5752 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
5753 }
5754 arg6 = (PLINT)(val6);
5755 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
5756 resultobj = SWIG_Py_Void();
5757 return resultobj;
5758fail:
5759 return NULL;
5760}
5761
5762
5763SWIGINTERN PyObject *_wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5764 PyObject *resultobj = 0;
5765 PLFLT arg1 ;
5766 PLFLT arg2 ;
5767 PLFLT arg3 ;
5768 PLFLT arg4 ;
5769 PLINT arg5 ;
5770 PLINT arg6 ;
5771 double val1 ;
5772 int ecode1 = 0 ;
5773 double val2 ;
5774 int ecode2 = 0 ;
5775 double val3 ;
5776 int ecode3 = 0 ;
5777 double val4 ;
5778 int ecode4 = 0 ;
5779 int val5 ;
5780 int ecode5 = 0 ;
5781 int val6 ;
5782 int ecode6 = 0 ;
5783 PyObject *swig_obj[6] ;
5784
5785 if (!SWIG_Python_UnpackTuple(args, "plenv0", 6, 6, swig_obj)) SWIG_fail;
5786 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5787 if (!SWIG_IsOK(ecode1)) {
5788 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
5789 }
5790 arg1 = (PLFLT)(val1);
5791 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5792 if (!SWIG_IsOK(ecode2)) {
5793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
5794 }
5795 arg2 = (PLFLT)(val2);
5796 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5797 if (!SWIG_IsOK(ecode3)) {
5798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
5799 }
5800 arg3 = (PLFLT)(val3);
5801 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5802 if (!SWIG_IsOK(ecode4)) {
5803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
5804 }
5805 arg4 = (PLFLT)(val4);
5806 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5807 if (!SWIG_IsOK(ecode5)) {
5808 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
5809 }
5810 arg5 = (PLINT)(val5);
5811 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5812 if (!SWIG_IsOK(ecode6)) {
5813 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
5814 }
5815 arg6 = (PLINT)(val6);
5816 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
5817 resultobj = SWIG_Py_Void();
5818 return resultobj;
5819fail:
5820 return NULL;
5821}
5822
5823
5824SWIGINTERN PyObject *_wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5825 PyObject *resultobj = 0;
5826
5827 if (!SWIG_Python_UnpackTuple(args, "pleop", 0, 0, 0)) SWIG_fail;
5828 pleop();
5829 resultobj = SWIG_Py_Void();
5830 return resultobj;
5831fail:
5832 return NULL;
5833}
5834
5835
5836SWIGINTERN PyObject *_wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5837 PyObject *resultobj = 0;
5838 PLINT arg1 ;
5839 PLFLT *arg2 = (PLFLT *) 0 ;
5840 PLFLT *arg3 = (PLFLT *) 0 ;
5841 PLFLT *arg4 = (PLFLT *) 0 ;
5842 PyArrayObject *tmp1 = NULL ;
5843 PyArrayObject *tmp3 = NULL ;
5844 PyArrayObject *tmp4 = NULL ;
5845 PyObject *swig_obj[3] ;
5846
5847 if (!SWIG_Python_UnpackTuple(args, "plerrx", 3, 3, swig_obj)) SWIG_fail;
5848 {
5849 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5850 if ( tmp1 == NULL )
5851 return NULL;
5852 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5853 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5854 }
5855 {
5856 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5857 if ( tmp3 == NULL )
5858 return NULL;
5859 if ( PyArray_DIMS( tmp3 )[0] != Alen )
5860 {
5861 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5862 return NULL;
5863 }
5864 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5865 }
5866 {
5867 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
5868 if ( tmp4 == NULL )
5869 return NULL;
5870 if ( PyArray_DIMS( tmp4 )[0] != Alen )
5871 {
5872 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5873 return NULL;
5874 }
5875 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
5876 }
5877 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
5878 resultobj = SWIG_Py_Void();
5879 {
5880 Py_CLEAR( tmp1 );
5881 }
5882 {
5883 Py_CLEAR( tmp3 );
5884 }
5885 {
5886 Py_CLEAR( tmp4 );
5887 }
5888 return resultobj;
5889fail:
5890 {
5891 Py_CLEAR( tmp1 );
5892 }
5893 {
5894 Py_CLEAR( tmp3 );
5895 }
5896 {
5897 Py_CLEAR( tmp4 );
5898 }
5899 return NULL;
5900}
5901
5902
5903SWIGINTERN PyObject *_wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5904 PyObject *resultobj = 0;
5905 PLINT arg1 ;
5906 PLFLT *arg2 = (PLFLT *) 0 ;
5907 PLFLT *arg3 = (PLFLT *) 0 ;
5908 PLFLT *arg4 = (PLFLT *) 0 ;
5909 PyArrayObject *tmp1 = NULL ;
5910 PyArrayObject *tmp3 = NULL ;
5911 PyArrayObject *tmp4 = NULL ;
5912 PyObject *swig_obj[3] ;
5913
5914 if (!SWIG_Python_UnpackTuple(args, "plerry", 3, 3, swig_obj)) SWIG_fail;
5915 {
5916 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5917 if ( tmp1 == NULL )
5918 return NULL;
5919 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5920 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5921 }
5922 {
5923 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5924 if ( tmp3 == NULL )
5925 return NULL;
5926 if ( PyArray_DIMS( tmp3 )[0] != Alen )
5927 {
5928 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5929 return NULL;
5930 }
5931 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5932 }
5933 {
5934 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
5935 if ( tmp4 == NULL )
5936 return NULL;
5937 if ( PyArray_DIMS( tmp4 )[0] != Alen )
5938 {
5939 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5940 return NULL;
5941 }
5942 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
5943 }
5944 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
5945 resultobj = SWIG_Py_Void();
5946 {
5947 Py_CLEAR( tmp1 );
5948 }
5949 {
5950 Py_CLEAR( tmp3 );
5951 }
5952 {
5953 Py_CLEAR( tmp4 );
5954 }
5955 return resultobj;
5956fail:
5957 {
5958 Py_CLEAR( tmp1 );
5959 }
5960 {
5961 Py_CLEAR( tmp3 );
5962 }
5963 {
5964 Py_CLEAR( tmp4 );
5965 }
5966 return NULL;
5967}
5968
5969
5970SWIGINTERN PyObject *_wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5971 PyObject *resultobj = 0;
5972
5973 if (!SWIG_Python_UnpackTuple(args, "plfamadv", 0, 0, 0)) SWIG_fail;
5974 plfamadv();
5975 resultobj = SWIG_Py_Void();
5976 return resultobj;
5977fail:
5978 return NULL;
5979}
5980
5981
5982SWIGINTERN PyObject *_wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5983 PyObject *resultobj = 0;
5984 PLINT arg1 ;
5985 PLFLT *arg2 = (PLFLT *) 0 ;
5986 PLFLT *arg3 = (PLFLT *) 0 ;
5987 PyArrayObject *tmp1 = NULL ;
5988 PyArrayObject *tmp3 = NULL ;
5989 PyObject *swig_obj[2] ;
5990
5991 if (!SWIG_Python_UnpackTuple(args, "plfill", 2, 2, swig_obj)) SWIG_fail;
5992 {
5993 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5994 if ( tmp1 == NULL )
5995 return NULL;
5996 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5997 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5998 }
5999 {
6000 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6001 if ( tmp3 == NULL )
6002 return NULL;
6003 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6004 {
6005 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6006 return NULL;
6007 }
6008 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6009 }
6010 plfill(arg1,(double const *)arg2,(double const *)arg3);
6011 resultobj = SWIG_Py_Void();
6012 {
6013 Py_CLEAR( tmp1 );
6014 }
6015 {
6016 Py_CLEAR( tmp3 );
6017 }
6018 return resultobj;
6019fail:
6020 {
6021 Py_CLEAR( tmp1 );
6022 }
6023 {
6024 Py_CLEAR( tmp3 );
6025 }
6026 return NULL;
6027}
6028
6029
6030SWIGINTERN PyObject *_wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6031 PyObject *resultobj = 0;
6032 PLINT arg1 ;
6033 PLFLT *arg2 = (PLFLT *) 0 ;
6034 PLFLT *arg3 = (PLFLT *) 0 ;
6035 PLFLT *arg4 = (PLFLT *) 0 ;
6036 PyArrayObject *tmp1 = NULL ;
6037 PyArrayObject *tmp3 = NULL ;
6038 PyArrayObject *tmp4 = NULL ;
6039 PyObject *swig_obj[3] ;
6040
6041 if (!SWIG_Python_UnpackTuple(args, "plfill3", 3, 3, swig_obj)) SWIG_fail;
6042 {
6043 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6044 if ( tmp1 == NULL )
6045 return NULL;
6046 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6047 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6048 }
6049 {
6050 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6051 if ( tmp3 == NULL )
6052 return NULL;
6053 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6054 {
6055 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6056 return NULL;
6057 }
6058 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6059 }
6060 {
6061 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6062 if ( tmp4 == NULL )
6063 return NULL;
6064 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6065 {
6066 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6067 return NULL;
6068 }
6069 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6070 }
6071 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6072 resultobj = SWIG_Py_Void();
6073 {
6074 Py_CLEAR( tmp1 );
6075 }
6076 {
6077 Py_CLEAR( tmp3 );
6078 }
6079 {
6080 Py_CLEAR( tmp4 );
6081 }
6082 return resultobj;
6083fail:
6084 {
6085 Py_CLEAR( tmp1 );
6086 }
6087 {
6088 Py_CLEAR( tmp3 );
6089 }
6090 {
6091 Py_CLEAR( tmp4 );
6092 }
6093 return NULL;
6094}
6095
6096
6097SWIGINTERN PyObject *_wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6098 PyObject *resultobj = 0;
6099 PLINT arg1 ;
6100 PLFLT *arg2 = (PLFLT *) 0 ;
6101 PLFLT *arg3 = (PLFLT *) 0 ;
6102 PLFLT arg4 ;
6103 PyArrayObject *tmp1 = NULL ;
6104 PyArrayObject *tmp3 = NULL ;
6105 double val4 ;
6106 int ecode4 = 0 ;
6107 PyObject *swig_obj[3] ;
6108
6109 if (!SWIG_Python_UnpackTuple(args, "plgradient", 3, 3, swig_obj)) SWIG_fail;
6110 {
6111 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6112 if ( tmp1 == NULL )
6113 return NULL;
6114 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6115 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6116 }
6117 {
6118 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6119 if ( tmp3 == NULL )
6120 return NULL;
6121 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6122 {
6123 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6124 return NULL;
6125 }
6126 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6127 }
6128 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
6129 if (!SWIG_IsOK(ecode4)) {
6130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6131 }
6132 arg4 = (PLFLT)(val4);
6133 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6134 resultobj = SWIG_Py_Void();
6135 {
6136 Py_CLEAR( tmp1 );
6137 }
6138 {
6139 Py_CLEAR( tmp3 );
6140 }
6141 return resultobj;
6142fail:
6143 {
6144 Py_CLEAR( tmp1 );
6145 }
6146 {
6147 Py_CLEAR( tmp3 );
6148 }
6149 return NULL;
6150}
6151
6152
6153SWIGINTERN PyObject *_wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6154 PyObject *resultobj = 0;
6155
6156 if (!SWIG_Python_UnpackTuple(args, "plflush", 0, 0, 0)) SWIG_fail;
6157 plflush();
6158 resultobj = SWIG_Py_Void();
6159 return resultobj;
6160fail:
6161 return NULL;
6162}
6163
6164
6165SWIGINTERN PyObject *_wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6166 PyObject *resultobj = 0;
6167 PLINT arg1 ;
6168 int val1 ;
6169 int ecode1 = 0 ;
6170 PyObject *swig_obj[1] ;
6171
6172 if (!args) SWIG_fail;
6173 swig_obj[0] = args;
6174 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6175 if (!SWIG_IsOK(ecode1)) {
6176 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6177 }
6178 arg1 = (PLINT)(val1);
6179 plfont(arg1);
6180 resultobj = SWIG_Py_Void();
6181 return resultobj;
6182fail:
6183 return NULL;
6184}
6185
6186
6187SWIGINTERN PyObject *_wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6188 PyObject *resultobj = 0;
6189 PLINT arg1 ;
6190 int val1 ;
6191 int ecode1 = 0 ;
6192 PyObject *swig_obj[1] ;
6193
6194 if (!args) SWIG_fail;
6195 swig_obj[0] = args;
6196 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6197 if (!SWIG_IsOK(ecode1)) {
6198 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6199 }
6200 arg1 = (PLINT)(val1);
6201 plfontld(arg1);
6202 resultobj = SWIG_Py_Void();
6203 return resultobj;
6204fail:
6205 return NULL;
6206}
6207
6208
6209SWIGINTERN PyObject *_wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6210 PyObject *resultobj = 0;
6211 PLFLT *arg1 = (PLFLT *) 0 ;
6212 PLFLT *arg2 = (PLFLT *) 0 ;
6213 PLFLT temp1 ;
6214 int res1 = SWIG_TMPOBJ ;
6215 PLFLT temp2 ;
6216 int res2 = SWIG_TMPOBJ ;
6217
6218 arg1 = &temp1;
6219 arg2 = &temp2;
6220 if (!SWIG_Python_UnpackTuple(args, "plgchr", 0, 0, 0)) SWIG_fail;
6221 plgchr(arg1,arg2);
6222 resultobj = SWIG_Py_Void();
6223 if (SWIG_IsTmpObj(res1)) {
6224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6225 } else {
6226 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6228 }
6229 if (SWIG_IsTmpObj(res2)) {
6230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6231 } else {
6232 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6234 }
6235 return resultobj;
6236fail:
6237 return NULL;
6238}
6239
6240
6241SWIGINTERN PyObject *_wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6242 PyObject *resultobj = 0;
6243 PLINT arg1 ;
6244 PLINT *arg2 = (PLINT *) 0 ;
6245 PLINT *arg3 = (PLINT *) 0 ;
6246 PLINT *arg4 = (PLINT *) 0 ;
6247 int val1 ;
6248 int ecode1 = 0 ;
6249 PLINT temp2 ;
6250 int res2 = SWIG_TMPOBJ ;
6251 PLINT temp3 ;
6252 int res3 = SWIG_TMPOBJ ;
6253 PLINT temp4 ;
6254 int res4 = SWIG_TMPOBJ ;
6255 PyObject *swig_obj[1] ;
6256
6257 arg2 = &temp2;
6258 arg3 = &temp3;
6259 arg4 = &temp4;
6260 if (!args) SWIG_fail;
6261 swig_obj[0] = args;
6262 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6263 if (!SWIG_IsOK(ecode1)) {
6264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6265 }
6266 arg1 = (PLINT)(val1);
6267 plgcol0(arg1,arg2,arg3,arg4);
6268 resultobj = SWIG_Py_Void();
6269 if (SWIG_IsTmpObj(res2)) {
6270 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6271 } else {
6272 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6274 }
6275 if (SWIG_IsTmpObj(res3)) {
6276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6277 } else {
6278 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6280 }
6281 if (SWIG_IsTmpObj(res4)) {
6282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6283 } else {
6284 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6286 }
6287 return resultobj;
6288fail:
6289 return NULL;
6290}
6291
6292
6293SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6294 PyObject *resultobj = 0;
6295 PLINT arg1 ;
6296 PLINT *arg2 = (PLINT *) 0 ;
6297 PLINT *arg3 = (PLINT *) 0 ;
6298 PLINT *arg4 = (PLINT *) 0 ;
6299 PLFLT *arg5 = (PLFLT *) 0 ;
6300 int val1 ;
6301 int ecode1 = 0 ;
6302 PLINT temp2 ;
6303 int res2 = SWIG_TMPOBJ ;
6304 PLINT temp3 ;
6305 int res3 = SWIG_TMPOBJ ;
6306 PLINT temp4 ;
6307 int res4 = SWIG_TMPOBJ ;
6308 PLFLT temp5 ;
6309 int res5 = SWIG_TMPOBJ ;
6310 PyObject *swig_obj[1] ;
6311
6312 arg2 = &temp2;
6313 arg3 = &temp3;
6314 arg4 = &temp4;
6315 arg5 = &temp5;
6316 if (!args) SWIG_fail;
6317 swig_obj[0] = args;
6318 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6319 if (!SWIG_IsOK(ecode1)) {
6320 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6321 }
6322 arg1 = (PLINT)(val1);
6323 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6324 resultobj = SWIG_Py_Void();
6325 if (SWIG_IsTmpObj(res2)) {
6326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6327 } else {
6328 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6329 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6330 }
6331 if (SWIG_IsTmpObj(res3)) {
6332 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6333 } else {
6334 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6335 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6336 }
6337 if (SWIG_IsTmpObj(res4)) {
6338 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6339 } else {
6340 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6341 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6342 }
6343 if (SWIG_IsTmpObj(res5)) {
6344 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6345 } else {
6346 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6347 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6348 }
6349 return resultobj;
6350fail:
6351 return NULL;
6352}
6353
6354
6355SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6356 PyObject *resultobj = 0;
6357 PLINT *arg1 = (PLINT *) 0 ;
6358 PLINT *arg2 = (PLINT *) 0 ;
6359 PLINT *arg3 = (PLINT *) 0 ;
6360 PLINT temp1 ;
6361 int res1 = SWIG_TMPOBJ ;
6362 PLINT temp2 ;
6363 int res2 = SWIG_TMPOBJ ;
6364 PLINT temp3 ;
6365 int res3 = SWIG_TMPOBJ ;
6366
6367 arg1 = &temp1;
6368 arg2 = &temp2;
6369 arg3 = &temp3;
6370 if (!SWIG_Python_UnpackTuple(args, "plgcolbg", 0, 0, 0)) SWIG_fail;
6371 plgcolbg(arg1,arg2,arg3);
6372 resultobj = SWIG_Py_Void();
6373 if (SWIG_IsTmpObj(res1)) {
6374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6375 } else {
6376 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6378 }
6379 if (SWIG_IsTmpObj(res2)) {
6380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6381 } else {
6382 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6384 }
6385 if (SWIG_IsTmpObj(res3)) {
6386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6387 } else {
6388 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6390 }
6391 return resultobj;
6392fail:
6393 return NULL;
6394}
6395
6396
6397SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6398 PyObject *resultobj = 0;
6399 PLINT *arg1 = (PLINT *) 0 ;
6400 PLINT *arg2 = (PLINT *) 0 ;
6401 PLINT *arg3 = (PLINT *) 0 ;
6402 PLFLT *arg4 = (PLFLT *) 0 ;
6403 PLINT temp1 ;
6404 int res1 = SWIG_TMPOBJ ;
6405 PLINT temp2 ;
6406 int res2 = SWIG_TMPOBJ ;
6407 PLINT temp3 ;
6408 int res3 = SWIG_TMPOBJ ;
6409 PLFLT temp4 ;
6410 int res4 = SWIG_TMPOBJ ;
6411
6412 arg1 = &temp1;
6413 arg2 = &temp2;
6414 arg3 = &temp3;
6415 arg4 = &temp4;
6416 if (!SWIG_Python_UnpackTuple(args, "plgcolbga", 0, 0, 0)) SWIG_fail;
6417 plgcolbga(arg1,arg2,arg3,arg4);
6418 resultobj = SWIG_Py_Void();
6419 if (SWIG_IsTmpObj(res1)) {
6420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6421 } else {
6422 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6424 }
6425 if (SWIG_IsTmpObj(res2)) {
6426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6427 } else {
6428 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6430 }
6431 if (SWIG_IsTmpObj(res3)) {
6432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6433 } else {
6434 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6435 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6436 }
6437 if (SWIG_IsTmpObj(res4)) {
6438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6439 } else {
6440 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6442 }
6443 return resultobj;
6444fail:
6445 return NULL;
6446}
6447
6448
6449SWIGINTERN PyObject *_wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6450 PyObject *resultobj = 0;
6451 PLINT *arg1 = (PLINT *) 0 ;
6452 PLINT temp1 ;
6453 int res1 = SWIG_TMPOBJ ;
6454
6455 arg1 = &temp1;
6456 if (!SWIG_Python_UnpackTuple(args, "plgcompression", 0, 0, 0)) SWIG_fail;
6457 plgcompression(arg1);
6458 resultobj = SWIG_Py_Void();
6459 if (SWIG_IsTmpObj(res1)) {
6460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6461 } else {
6462 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6464 }
6465 return resultobj;
6466fail:
6467 return NULL;
6468}
6469
6470
6471SWIGINTERN PyObject *_wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6472 PyObject *resultobj = 0;
6473 char *arg1 = (char *) 0 ;
6474 char buff1[1000] ;
6475
6476 {
6477 arg1 = buff1;
6478 }
6479 if (!SWIG_Python_UnpackTuple(args, "plgdev", 0, 0, 0)) SWIG_fail;
6480 plgdev(arg1);
6481 resultobj = SWIG_Py_Void();
6482 {
6483 PyObject *o = PyString_FromString( arg1 );
6484 resultobj = t_output_helper( resultobj, o );
6485 }
6486 return resultobj;
6487fail:
6488 return NULL;
6489}
6490
6491
6492SWIGINTERN PyObject *_wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6493 PyObject *resultobj = 0;
6494 PLFLT *arg1 = (PLFLT *) 0 ;
6495 PLFLT *arg2 = (PLFLT *) 0 ;
6496 PLFLT *arg3 = (PLFLT *) 0 ;
6497 PLFLT *arg4 = (PLFLT *) 0 ;
6498 PLFLT temp1 ;
6499 int res1 = SWIG_TMPOBJ ;
6500 PLFLT temp2 ;
6501 int res2 = SWIG_TMPOBJ ;
6502 PLFLT temp3 ;
6503 int res3 = SWIG_TMPOBJ ;
6504 PLFLT temp4 ;
6505 int res4 = SWIG_TMPOBJ ;
6506
6507 arg1 = &temp1;
6508 arg2 = &temp2;
6509 arg3 = &temp3;
6510 arg4 = &temp4;
6511 if (!SWIG_Python_UnpackTuple(args, "plgdidev", 0, 0, 0)) SWIG_fail;
6512 plgdidev(arg1,arg2,arg3,arg4);
6513 resultobj = SWIG_Py_Void();
6514 if (SWIG_IsTmpObj(res1)) {
6515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6516 } else {
6517 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6519 }
6520 if (SWIG_IsTmpObj(res2)) {
6521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6522 } else {
6523 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6525 }
6526 if (SWIG_IsTmpObj(res3)) {
6527 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6528 } else {
6529 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6530 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6531 }
6532 if (SWIG_IsTmpObj(res4)) {
6533 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6534 } else {
6535 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6537 }
6538 return resultobj;
6539fail:
6540 return NULL;
6541}
6542
6543
6544SWIGINTERN PyObject *_wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6545 PyObject *resultobj = 0;
6546 PLFLT *arg1 = (PLFLT *) 0 ;
6547 PLFLT temp1 ;
6548 int res1 = SWIG_TMPOBJ ;
6549
6550 arg1 = &temp1;
6551 if (!SWIG_Python_UnpackTuple(args, "plgdiori", 0, 0, 0)) SWIG_fail;
6552 plgdiori(arg1);
6553 resultobj = SWIG_Py_Void();
6554 if (SWIG_IsTmpObj(res1)) {
6555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6556 } else {
6557 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6559 }
6560 return resultobj;
6561fail:
6562 return NULL;
6563}
6564
6565
6566SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6567 PyObject *resultobj = 0;
6568 PLFLT *arg1 = (PLFLT *) 0 ;
6569 PLFLT *arg2 = (PLFLT *) 0 ;
6570 PLFLT *arg3 = (PLFLT *) 0 ;
6571 PLFLT *arg4 = (PLFLT *) 0 ;
6572 PLFLT temp1 ;
6573 int res1 = SWIG_TMPOBJ ;
6574 PLFLT temp2 ;
6575 int res2 = SWIG_TMPOBJ ;
6576 PLFLT temp3 ;
6577 int res3 = SWIG_TMPOBJ ;
6578 PLFLT temp4 ;
6579 int res4 = SWIG_TMPOBJ ;
6580
6581 arg1 = &temp1;
6582 arg2 = &temp2;
6583 arg3 = &temp3;
6584 arg4 = &temp4;
6585 if (!SWIG_Python_UnpackTuple(args, "plgdiplt", 0, 0, 0)) SWIG_fail;
6586 plgdiplt(arg1,arg2,arg3,arg4);
6587 resultobj = SWIG_Py_Void();
6588 if (SWIG_IsTmpObj(res1)) {
6589 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6590 } else {
6591 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6592 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6593 }
6594 if (SWIG_IsTmpObj(res2)) {
6595 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6596 } else {
6597 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6598 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6599 }
6600 if (SWIG_IsTmpObj(res3)) {
6601 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6602 } else {
6603 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6604 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6605 }
6606 if (SWIG_IsTmpObj(res4)) {
6607 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6608 } else {
6609 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6610 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6611 }
6612 return resultobj;
6613fail:
6614 return NULL;
6615}
6616
6617
6618SWIGINTERN PyObject *_wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6619 PyObject *resultobj = 0;
6620 PLINT *arg1 = (PLINT *) 0 ;
6621 PLINT *arg2 = (PLINT *) 0 ;
6622 PLINT *arg3 = (PLINT *) 0 ;
6623 PLINT temp1 ;
6624 int res1 = SWIG_TMPOBJ ;
6625 PLINT temp2 ;
6626 int res2 = SWIG_TMPOBJ ;
6627 PLINT temp3 ;
6628 int res3 = SWIG_TMPOBJ ;
6629
6630 arg1 = &temp1;
6631 arg2 = &temp2;
6632 arg3 = &temp3;
6633 if (!SWIG_Python_UnpackTuple(args, "plgfam", 0, 0, 0)) SWIG_fail;
6634 plgfam(arg1,arg2,arg3);
6635 resultobj = SWIG_Py_Void();
6636 if (SWIG_IsTmpObj(res1)) {
6637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6638 } else {
6639 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6641 }
6642 if (SWIG_IsTmpObj(res2)) {
6643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6644 } else {
6645 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6647 }
6648 if (SWIG_IsTmpObj(res3)) {
6649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6650 } else {
6651 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6653 }
6654 return resultobj;
6655fail:
6656 return NULL;
6657}
6658
6659
6660SWIGINTERN PyObject *_wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6661 PyObject *resultobj = 0;
6662 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
6663 PLUNICODE temp1 ;
6664 int res1 = SWIG_TMPOBJ ;
6665
6666 arg1 = &temp1;
6667 if (!SWIG_Python_UnpackTuple(args, "plgfci", 0, 0, 0)) SWIG_fail;
6668 plgfci(arg1);
6669 resultobj = SWIG_Py_Void();
6670 if (SWIG_IsTmpObj(res1)) {
6671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
6672 } else {
6673 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
6675 }
6676 return resultobj;
6677fail:
6678 return NULL;
6679}
6680
6681
6682SWIGINTERN PyObject *_wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6683 PyObject *resultobj = 0;
6684 char *arg1 = (char *) 0 ;
6685 char buff1[1000] ;
6686
6687 {
6688 arg1 = buff1;
6689 }
6690 if (!SWIG_Python_UnpackTuple(args, "plgfnam", 0, 0, 0)) SWIG_fail;
6691 plgfnam(arg1);
6692 resultobj = SWIG_Py_Void();
6693 {
6694 PyObject *o = PyString_FromString( arg1 );
6695 resultobj = t_output_helper( resultobj, o );
6696 }
6697 return resultobj;
6698fail:
6699 return NULL;
6700}
6701
6702
6703SWIGINTERN PyObject *_wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6704 PyObject *resultobj = 0;
6705 PLINT *arg1 = (PLINT *) 0 ;
6706 PLINT *arg2 = (PLINT *) 0 ;
6707 PLINT *arg3 = (PLINT *) 0 ;
6708 PLINT temp1 ;
6709 int res1 = SWIG_TMPOBJ ;
6710 PLINT temp2 ;
6711 int res2 = SWIG_TMPOBJ ;
6712 PLINT temp3 ;
6713 int res3 = SWIG_TMPOBJ ;
6714
6715 arg1 = &temp1;
6716 arg2 = &temp2;
6717 arg3 = &temp3;
6718 if (!SWIG_Python_UnpackTuple(args, "plgfont", 0, 0, 0)) SWIG_fail;
6719 plgfont(arg1,arg2,arg3);
6720 resultobj = SWIG_Py_Void();
6721 if (SWIG_IsTmpObj(res1)) {
6722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6723 } else {
6724 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6726 }
6727 if (SWIG_IsTmpObj(res2)) {
6728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6729 } else {
6730 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6732 }
6733 if (SWIG_IsTmpObj(res3)) {
6734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6735 } else {
6736 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6738 }
6739 return resultobj;
6740fail:
6741 return NULL;
6742}
6743
6744
6745SWIGINTERN PyObject *_wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6746 PyObject *resultobj = 0;
6747 PLINT *arg1 = (PLINT *) 0 ;
6748 PLINT temp1 ;
6749 int res1 = SWIG_TMPOBJ ;
6750
6751 arg1 = &temp1;
6752 if (!SWIG_Python_UnpackTuple(args, "plglevel", 0, 0, 0)) SWIG_fail;
6753 plglevel(arg1);
6754 resultobj = SWIG_Py_Void();
6755 if (SWIG_IsTmpObj(res1)) {
6756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6757 } else {
6758 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6760 }
6761 return resultobj;
6762fail:
6763 return NULL;
6764}
6765
6766
6767SWIGINTERN PyObject *_wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6768 PyObject *resultobj = 0;
6769 PLFLT *arg1 = (PLFLT *) 0 ;
6770 PLFLT *arg2 = (PLFLT *) 0 ;
6771 PLINT *arg3 = (PLINT *) 0 ;
6772 PLINT *arg4 = (PLINT *) 0 ;
6773 PLINT *arg5 = (PLINT *) 0 ;
6774 PLINT *arg6 = (PLINT *) 0 ;
6775 PLFLT temp1 ;
6776 int res1 = SWIG_TMPOBJ ;
6777 PLFLT temp2 ;
6778 int res2 = SWIG_TMPOBJ ;
6779 PLINT temp3 ;
6780 int res3 = SWIG_TMPOBJ ;
6781 PLINT temp4 ;
6782 int res4 = SWIG_TMPOBJ ;
6783 PLINT temp5 ;
6784 int res5 = SWIG_TMPOBJ ;
6785 PLINT temp6 ;
6786 int res6 = SWIG_TMPOBJ ;
6787
6788 arg1 = &temp1;
6789 arg2 = &temp2;
6790 arg3 = &temp3;
6791 arg4 = &temp4;
6792 arg5 = &temp5;
6793 arg6 = &temp6;
6794 if (!SWIG_Python_UnpackTuple(args, "plgpage", 0, 0, 0)) SWIG_fail;
6795 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
6796 resultobj = SWIG_Py_Void();
6797 if (SWIG_IsTmpObj(res1)) {
6798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6799 } else {
6800 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6802 }
6803 if (SWIG_IsTmpObj(res2)) {
6804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6805 } else {
6806 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6808 }
6809 if (SWIG_IsTmpObj(res3)) {
6810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6811 } else {
6812 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6814 }
6815 if (SWIG_IsTmpObj(res4)) {
6816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6817 } else {
6818 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6820 }
6821 if (SWIG_IsTmpObj(res5)) {
6822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
6823 } else {
6824 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
6826 }
6827 if (SWIG_IsTmpObj(res6)) {
6828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
6829 } else {
6830 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6831 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
6832 }
6833 return resultobj;
6834fail:
6835 return NULL;
6836}
6837
6838
6839SWIGINTERN PyObject *_wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6840 PyObject *resultobj = 0;
6841
6842 if (!SWIG_Python_UnpackTuple(args, "plgra", 0, 0, 0)) SWIG_fail;
6843 plgra();
6844 resultobj = SWIG_Py_Void();
6845 return resultobj;
6846fail:
6847 return NULL;
6848}
6849
6850
6851SWIGINTERN PyObject *_wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6852 PyObject *resultobj = 0;
6853 PLFLT *arg1 = (PLFLT *) 0 ;
6854 PLFLT *arg2 = (PLFLT *) 0 ;
6855 PLFLT *arg3 = (PLFLT *) 0 ;
6856 PLINT arg4 ;
6857 PLFLT *arg5 = (PLFLT *) 0 ;
6858 PLINT arg6 ;
6859 PLFLT *arg7 = (PLFLT *) 0 ;
6860 PLINT arg8 ;
6861 PLFLT **arg9 = (PLFLT **) 0 ;
6862 PLINT arg10 ;
6863 PLFLT arg11 ;
6864 PyArrayObject *tmp1 = NULL ;
6865 PyArrayObject *tmp2 = NULL ;
6866 PyArrayObject *tmp3 = NULL ;
6867 PyArrayObject *tmp5 = NULL ;
6868 PyArrayObject *tmp7 = NULL ;
6869 PyObject *array7 = NULL ;
6870 int val10 ;
6871 int ecode10 = 0 ;
6872 double val11 ;
6873 int ecode11 = 0 ;
6874 PyObject *swig_obj[7] ;
6875
6876 if (!SWIG_Python_UnpackTuple(args, "plgriddata", 7, 7, swig_obj)) SWIG_fail;
6877 {
6878 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6879 if ( tmp1 == NULL )
6880 return NULL;
6881 Alen = PyArray_DIMS( tmp1 )[0];
6882 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
6883 }
6884 {
6885 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6886 if ( tmp2 == NULL )
6887 return NULL;
6888 if ( PyArray_DIMS( tmp2 )[0] != Alen )
6889 {
6890 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6891 return NULL;
6892 }
6893 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
6894 }
6895 {
6896 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6897 if ( tmp3 == NULL )
6898 return NULL;
6899 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6900 {
6901 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6902 return NULL;
6903 }
6904 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6905 arg4 = PyArray_DIMS( tmp3 )[0];
6906 }
6907 {
6908 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
6909 if ( tmp5 == NULL )
6910 return NULL;
6911 Xlen = PyArray_DIMS( tmp5 )[0];
6912 arg6 = Xlen;
6913 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
6914 }
6915 {
6916 int i, size;
6917 npy_intp dims[2];
6918 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
6919 if ( tmp7 == NULL )
6920 return NULL;
6921 Ylen = PyArray_DIMS( tmp7 )[0];
6922 arg8 = Ylen;
6923 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
6924 // Make created 2D array7 have dimensions from prior ArrayX in the argument
6925 // list and this ArrayY.
6926 dims[0] = Xlen;
6927 dims[1] = Ylen;
6928 array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
6929 if ( !array7 )
6930 return NULL;
6931 size = Ylen;
6932 arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
6933 for ( i = 0; i < Xlen; i++ )
6934 arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
6935 }
6936 ecode10 = SWIG_AsVal_int(swig_obj[5], &val10);
6937 if (!SWIG_IsOK(ecode10)) {
6938 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
6939 }
6940 arg10 = (PLINT)(val10);
6941 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
6942 if (!SWIG_IsOK(ecode11)) {
6943 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
6944 }
6945 arg11 = (PLFLT)(val11);
6946 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
6947 resultobj = SWIG_Py_Void();
6948 {
6949 resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
6950 }
6951 {
6952 Py_CLEAR( tmp1 );
6953 }
6954 {
6955 Py_CLEAR( tmp2 );
6956 }
6957 {
6958 Py_CLEAR( tmp3 );
6959 }
6960 {
6961 Py_CLEAR( tmp5 );
6962 }
6963 {
6964 Py_CLEAR( tmp7 );
6965 free( arg9 );
6966 }
6967 return resultobj;
6968fail:
6969 {
6970 Py_CLEAR( tmp1 );
6971 }
6972 {
6973 Py_CLEAR( tmp2 );
6974 }
6975 {
6976 Py_CLEAR( tmp3 );
6977 }
6978 {
6979 Py_CLEAR( tmp5 );
6980 }
6981 {
6982 Py_CLEAR( tmp7 );
6983 free( arg9 );
6984 }
6985 return NULL;
6986}
6987
6988
6989SWIGINTERN PyObject *_wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6990 PyObject *resultobj = 0;
6991 PLFLT *arg1 = (PLFLT *) 0 ;
6992 PLFLT *arg2 = (PLFLT *) 0 ;
6993 PLFLT *arg3 = (PLFLT *) 0 ;
6994 PLFLT *arg4 = (PLFLT *) 0 ;
6995 PLFLT temp1 ;
6996 int res1 = SWIG_TMPOBJ ;
6997 PLFLT temp2 ;
6998 int res2 = SWIG_TMPOBJ ;
6999 PLFLT temp3 ;
7000 int res3 = SWIG_TMPOBJ ;
7001 PLFLT temp4 ;
7002 int res4 = SWIG_TMPOBJ ;
7003
7004 arg1 = &temp1;
7005 arg2 = &temp2;
7006 arg3 = &temp3;
7007 arg4 = &temp4;
7008 if (!SWIG_Python_UnpackTuple(args, "plgspa", 0, 0, 0)) SWIG_fail;
7009 plgspa(arg1,arg2,arg3,arg4);
7010 resultobj = SWIG_Py_Void();
7011 if (SWIG_IsTmpObj(res1)) {
7012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7013 } else {
7014 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7016 }
7017 if (SWIG_IsTmpObj(res2)) {
7018 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7019 } else {
7020 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7021 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7022 }
7023 if (SWIG_IsTmpObj(res3)) {
7024 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7025 } else {
7026 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7027 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7028 }
7029 if (SWIG_IsTmpObj(res4)) {
7030 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7031 } else {
7032 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7033 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7034 }
7035 return resultobj;
7036fail:
7037 return NULL;
7038}
7039
7040
7041SWIGINTERN PyObject *_wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7042 PyObject *resultobj = 0;
7043 PLINT *arg1 = (PLINT *) 0 ;
7044 PLINT temp1 ;
7045 int res1 = SWIG_TMPOBJ ;
7046
7047 arg1 = &temp1;
7048 if (!SWIG_Python_UnpackTuple(args, "plgstrm", 0, 0, 0)) SWIG_fail;
7049 plgstrm(arg1);
7050 resultobj = SWIG_Py_Void();
7051 if (SWIG_IsTmpObj(res1)) {
7052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7053 } else {
7054 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7055 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7056 }
7057 return resultobj;
7058fail:
7059 return NULL;
7060}
7061
7062
7063SWIGINTERN PyObject *_wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7064 PyObject *resultobj = 0;
7065 char *arg1 = (char *) 0 ;
7066 char buff1[1000] ;
7067
7068 {
7069 arg1 = buff1;
7070 }
7071 if (!SWIG_Python_UnpackTuple(args, "plgver", 0, 0, 0)) SWIG_fail;
7072 plgver(arg1);
7073 resultobj = SWIG_Py_Void();
7074 {
7075 PyObject *o = PyString_FromString( arg1 );
7076 resultobj = t_output_helper( resultobj, o );
7077 }
7078 return resultobj;
7079fail:
7080 return NULL;
7081}
7082
7083
7084SWIGINTERN PyObject *_wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7085 PyObject *resultobj = 0;
7086 PLFLT *arg1 = (PLFLT *) 0 ;
7087 PLFLT *arg2 = (PLFLT *) 0 ;
7088 PLFLT *arg3 = (PLFLT *) 0 ;
7089 PLFLT *arg4 = (PLFLT *) 0 ;
7090 PLFLT temp1 ;
7091 int res1 = SWIG_TMPOBJ ;
7092 PLFLT temp2 ;
7093 int res2 = SWIG_TMPOBJ ;
7094 PLFLT temp3 ;
7095 int res3 = SWIG_TMPOBJ ;
7096 PLFLT temp4 ;
7097 int res4 = SWIG_TMPOBJ ;
7098
7099 arg1 = &temp1;
7100 arg2 = &temp2;
7101 arg3 = &temp3;
7102 arg4 = &temp4;
7103 if (!SWIG_Python_UnpackTuple(args, "plgvpd", 0, 0, 0)) SWIG_fail;
7104 plgvpd(arg1,arg2,arg3,arg4);
7105 resultobj = SWIG_Py_Void();
7106 if (SWIG_IsTmpObj(res1)) {
7107 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7108 } else {
7109 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7110 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7111 }
7112 if (SWIG_IsTmpObj(res2)) {
7113 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7114 } else {
7115 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7116 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7117 }
7118 if (SWIG_IsTmpObj(res3)) {
7119 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7120 } else {
7121 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7122 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7123 }
7124 if (SWIG_IsTmpObj(res4)) {
7125 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7126 } else {
7127 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7128 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7129 }
7130 return resultobj;
7131fail:
7132 return NULL;
7133}
7134
7135
7136SWIGINTERN PyObject *_wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7137 PyObject *resultobj = 0;
7138 PLFLT *arg1 = (PLFLT *) 0 ;
7139 PLFLT *arg2 = (PLFLT *) 0 ;
7140 PLFLT *arg3 = (PLFLT *) 0 ;
7141 PLFLT *arg4 = (PLFLT *) 0 ;
7142 PLFLT temp1 ;
7143 int res1 = SWIG_TMPOBJ ;
7144 PLFLT temp2 ;
7145 int res2 = SWIG_TMPOBJ ;
7146 PLFLT temp3 ;
7147 int res3 = SWIG_TMPOBJ ;
7148 PLFLT temp4 ;
7149 int res4 = SWIG_TMPOBJ ;
7150
7151 arg1 = &temp1;
7152 arg2 = &temp2;
7153 arg3 = &temp3;
7154 arg4 = &temp4;
7155 if (!SWIG_Python_UnpackTuple(args, "plgvpw", 0, 0, 0)) SWIG_fail;
7156 plgvpw(arg1,arg2,arg3,arg4);
7157 resultobj = SWIG_Py_Void();
7158 if (SWIG_IsTmpObj(res1)) {
7159 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7160 } else {
7161 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7162 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7163 }
7164 if (SWIG_IsTmpObj(res2)) {
7165 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7166 } else {
7167 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7168 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7169 }
7170 if (SWIG_IsTmpObj(res3)) {
7171 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7172 } else {
7173 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7175 }
7176 if (SWIG_IsTmpObj(res4)) {
7177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7178 } else {
7179 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7181 }
7182 return resultobj;
7183fail:
7184 return NULL;
7185}
7186
7187
7188SWIGINTERN PyObject *_wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7189 PyObject *resultobj = 0;
7190 PLINT *arg1 = (PLINT *) 0 ;
7191 PLINT *arg2 = (PLINT *) 0 ;
7192 PLINT temp1 ;
7193 int res1 = SWIG_TMPOBJ ;
7194 PLINT temp2 ;
7195 int res2 = SWIG_TMPOBJ ;
7196
7197 arg1 = &temp1;
7198 arg2 = &temp2;
7199 if (!SWIG_Python_UnpackTuple(args, "plgxax", 0, 0, 0)) SWIG_fail;
7200 plgxax(arg1,arg2);
7201 resultobj = SWIG_Py_Void();
7202 if (SWIG_IsTmpObj(res1)) {
7203 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7204 } else {
7205 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7206 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7207 }
7208 if (SWIG_IsTmpObj(res2)) {
7209 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7210 } else {
7211 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7213 }
7214 return resultobj;
7215fail:
7216 return NULL;
7217}
7218
7219
7220SWIGINTERN PyObject *_wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7221 PyObject *resultobj = 0;
7222 PLINT *arg1 = (PLINT *) 0 ;
7223 PLINT *arg2 = (PLINT *) 0 ;
7224 PLINT temp1 ;
7225 int res1 = SWIG_TMPOBJ ;
7226 PLINT temp2 ;
7227 int res2 = SWIG_TMPOBJ ;
7228
7229 arg1 = &temp1;
7230 arg2 = &temp2;
7231 if (!SWIG_Python_UnpackTuple(args, "plgyax", 0, 0, 0)) SWIG_fail;
7232 plgyax(arg1,arg2);
7233 resultobj = SWIG_Py_Void();
7234 if (SWIG_IsTmpObj(res1)) {
7235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7236 } else {
7237 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7239 }
7240 if (SWIG_IsTmpObj(res2)) {
7241 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7242 } else {
7243 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7244 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7245 }
7246 return resultobj;
7247fail:
7248 return NULL;
7249}
7250
7251
7252SWIGINTERN PyObject *_wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7253 PyObject *resultobj = 0;
7254 PLINT *arg1 = (PLINT *) 0 ;
7255 PLINT *arg2 = (PLINT *) 0 ;
7256 PLINT temp1 ;
7257 int res1 = SWIG_TMPOBJ ;
7258 PLINT temp2 ;
7259 int res2 = SWIG_TMPOBJ ;
7260
7261 arg1 = &temp1;
7262 arg2 = &temp2;
7263 if (!SWIG_Python_UnpackTuple(args, "plgzax", 0, 0, 0)) SWIG_fail;
7264 plgzax(arg1,arg2);
7265 resultobj = SWIG_Py_Void();
7266 if (SWIG_IsTmpObj(res1)) {
7267 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7268 } else {
7269 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7270 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7271 }
7272 if (SWIG_IsTmpObj(res2)) {
7273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7274 } else {
7275 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7277 }
7278 return resultobj;
7279fail:
7280 return NULL;
7281}
7282
7283
7284SWIGINTERN PyObject *_wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7285 PyObject *resultobj = 0;
7286 PLINT arg1 ;
7287 PLFLT *arg2 = (PLFLT *) 0 ;
7288 PLFLT arg3 ;
7289 PLFLT arg4 ;
7290 PLINT arg5 ;
7291 PLINT arg6 ;
7292 PyArrayObject *tmp1 = NULL ;
7293 double val3 ;
7294 int ecode3 = 0 ;
7295 double val4 ;
7296 int ecode4 = 0 ;
7297 int val5 ;
7298 int ecode5 = 0 ;
7299 int val6 ;
7300 int ecode6 = 0 ;
7301 PyObject *swig_obj[5] ;
7302
7303 if (!SWIG_Python_UnpackTuple(args, "plhist", 5, 5, swig_obj)) SWIG_fail;
7304 {
7305 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7306 if ( tmp1 == NULL )
7307 return NULL;
7308 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7309 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7310 }
7311 ecode3 = SWIG_AsVal_double(swig_obj[1], &val3);
7312 if (!SWIG_IsOK(ecode3)) {
7313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7314 }
7315 arg3 = (PLFLT)(val3);
7316 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
7317 if (!SWIG_IsOK(ecode4)) {
7318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7319 }
7320 arg4 = (PLFLT)(val4);
7321 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
7322 if (!SWIG_IsOK(ecode5)) {
7323 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7324 }
7325 arg5 = (PLINT)(val5);
7326 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
7327 if (!SWIG_IsOK(ecode6)) {
7328 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7329 }
7330 arg6 = (PLINT)(val6);
7331 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7332 resultobj = SWIG_Py_Void();
7333 {
7334 Py_CLEAR( tmp1 );
7335 }
7336 return resultobj;
7337fail:
7338 {
7339 Py_CLEAR( tmp1 );
7340 }
7341 return NULL;
7342}
7343
7344
7345SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7346 PyObject *resultobj = 0;
7347 PLFLT arg1 ;
7348 PLFLT arg2 ;
7349 PLFLT arg3 ;
7350 PLFLT *arg4 = (PLFLT *) 0 ;
7351 PLFLT *arg5 = (PLFLT *) 0 ;
7352 PLFLT *arg6 = (PLFLT *) 0 ;
7353 double val1 ;
7354 int ecode1 = 0 ;
7355 double val2 ;
7356 int ecode2 = 0 ;
7357 double val3 ;
7358 int ecode3 = 0 ;
7359 PLFLT temp4 ;
7360 int res4 = SWIG_TMPOBJ ;
7361 PLFLT temp5 ;
7362 int res5 = SWIG_TMPOBJ ;
7363 PLFLT temp6 ;
7364 int res6 = SWIG_TMPOBJ ;
7365 PyObject *swig_obj[3] ;
7366
7367 arg4 = &temp4;
7368 arg5 = &temp5;
7369 arg6 = &temp6;
7370 if (!SWIG_Python_UnpackTuple(args, "plhlsrgb", 3, 3, swig_obj)) SWIG_fail;
7371 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7372 if (!SWIG_IsOK(ecode1)) {
7373 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7374 }
7375 arg1 = (PLFLT)(val1);
7376 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7377 if (!SWIG_IsOK(ecode2)) {
7378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7379 }
7380 arg2 = (PLFLT)(val2);
7381 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7382 if (!SWIG_IsOK(ecode3)) {
7383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7384 }
7385 arg3 = (PLFLT)(val3);
7386 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7387 resultobj = SWIG_Py_Void();
7388 if (SWIG_IsTmpObj(res4)) {
7389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7390 } else {
7391 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7393 }
7394 if (SWIG_IsTmpObj(res5)) {
7395 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7396 } else {
7397 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7398 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7399 }
7400 if (SWIG_IsTmpObj(res6)) {
7401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7402 } else {
7403 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7405 }
7406 return resultobj;
7407fail:
7408 return NULL;
7409}
7410
7411
7412SWIGINTERN PyObject *_wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7413 PyObject *resultobj = 0;
7414
7415 if (!SWIG_Python_UnpackTuple(args, "plinit", 0, 0, 0)) SWIG_fail;
7416 plinit();
7417 resultobj = SWIG_Py_Void();
7418 return resultobj;
7419fail:
7420 return NULL;
7421}
7422
7423
7424SWIGINTERN PyObject *_wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7425 PyObject *resultobj = 0;
7426 PLFLT arg1 ;
7427 PLFLT arg2 ;
7428 PLFLT arg3 ;
7429 PLFLT arg4 ;
7430 double val1 ;
7431 int ecode1 = 0 ;
7432 double val2 ;
7433 int ecode2 = 0 ;
7434 double val3 ;
7435 int ecode3 = 0 ;
7436 double val4 ;
7437 int ecode4 = 0 ;
7438 PyObject *swig_obj[4] ;
7439
7440 if (!SWIG_Python_UnpackTuple(args, "pljoin", 4, 4, swig_obj)) SWIG_fail;
7441 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7442 if (!SWIG_IsOK(ecode1)) {
7443 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7444 }
7445 arg1 = (PLFLT)(val1);
7446 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7447 if (!SWIG_IsOK(ecode2)) {
7448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7449 }
7450 arg2 = (PLFLT)(val2);
7451 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7452 if (!SWIG_IsOK(ecode3)) {
7453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7454 }
7455 arg3 = (PLFLT)(val3);
7456 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
7457 if (!SWIG_IsOK(ecode4)) {
7458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7459 }
7460 arg4 = (PLFLT)(val4);
7461 pljoin(arg1,arg2,arg3,arg4);
7462 resultobj = SWIG_Py_Void();
7463 return resultobj;
7464fail:
7465 return NULL;
7466}
7467
7468
7469SWIGINTERN PyObject *_wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7470 PyObject *resultobj = 0;
7471 char *arg1 = (char *) 0 ;
7472 char *arg2 = (char *) 0 ;
7473 char *arg3 = (char *) 0 ;
7474 int res1 ;
7475 char *buf1 = 0 ;
7476 int alloc1 = 0 ;
7477 int res2 ;
7478 char *buf2 = 0 ;
7479 int alloc2 = 0 ;
7480 int res3 ;
7481 char *buf3 = 0 ;
7482 int alloc3 = 0 ;
7483 PyObject *swig_obj[3] ;
7484
7485 if (!SWIG_Python_UnpackTuple(args, "pllab", 3, 3, swig_obj)) SWIG_fail;
7486 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
7487 if (!SWIG_IsOK(res1)) {
7488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7489 }
7490 arg1 = (char *)(buf1);
7491 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7492 if (!SWIG_IsOK(res2)) {
7493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7494 }
7495 arg2 = (char *)(buf2);
7496 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
7497 if (!SWIG_IsOK(res3)) {
7498 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7499 }
7500 arg3 = (char *)(buf3);
7501 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7502 resultobj = SWIG_Py_Void();
7503 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7504 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7505 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7506 return resultobj;
7507fail:
7508 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7509 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7510 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7511 return NULL;
7512}
7513
7514
7515SWIGINTERN PyObject *_wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7516 PyObject *resultobj = 0;
7517 PLFLT *arg1 = (PLFLT *) 0 ;
7518 PLFLT *arg2 = (PLFLT *) 0 ;
7519 PLINT arg3 ;
7520 PLINT arg4 ;
7521 PLFLT arg5 ;
7522 PLFLT arg6 ;
7523 PLFLT arg7 ;
7524 PLINT arg8 ;
7525 PLINT arg9 ;
7526 PLINT arg10 ;
7527 PLINT arg11 ;
7528 PLINT arg12 ;
7529 PLINT arg13 ;
7530 PLINT *arg14 = (PLINT *) 0 ;
7531 PLFLT arg15 ;
7532 PLFLT arg16 ;
7533 PLFLT arg17 ;
7534 PLFLT arg18 ;
7535 PLINT *arg19 = (PLINT *) 0 ;
7536 char **arg20 = (char **) 0 ;
7537 PLINT *arg21 = (PLINT *) 0 ;
7538 PLINT *arg22 = (PLINT *) 0 ;
7539 PLFLT *arg23 = (PLFLT *) 0 ;
7540 PLFLT *arg24 = (PLFLT *) 0 ;
7541 PLINT *arg25 = (PLINT *) 0 ;
7542 PLINT *arg26 = (PLINT *) 0 ;
7543 PLFLT *arg27 = (PLFLT *) 0 ;
7544 PLINT *arg28 = (PLINT *) 0 ;
7545 PLFLT *arg29 = (PLFLT *) 0 ;
7546 PLINT *arg30 = (PLINT *) 0 ;
7547 char **arg31 = (char **) 0 ;
7548 PLFLT temp1 ;
7549 int res1 = SWIG_TMPOBJ ;
7550 PLFLT temp2 ;
7551 int res2 = SWIG_TMPOBJ ;
7552 int val3 ;
7553 int ecode3 = 0 ;
7554 int val4 ;
7555 int ecode4 = 0 ;
7556 double val5 ;
7557 int ecode5 = 0 ;
7558 double val6 ;
7559 int ecode6 = 0 ;
7560 double val7 ;
7561 int ecode7 = 0 ;
7562 int val8 ;
7563 int ecode8 = 0 ;
7564 int val9 ;
7565 int ecode9 = 0 ;
7566 int val10 ;
7567 int ecode10 = 0 ;
7568 int val11 ;
7569 int ecode11 = 0 ;
7570 int val12 ;
7571 int ecode12 = 0 ;
7572 PyArrayObject *tmp13 = NULL ;
7573 double val15 ;
7574 int ecode15 = 0 ;
7575 double val16 ;
7576 int ecode16 = 0 ;
7577 double val17 ;
7578 int ecode17 = 0 ;
7579 double val18 ;
7580 int ecode18 = 0 ;
7581 PyArrayObject *tmp19 = NULL ;
7582 PyArrayObject *tmp20 = NULL ;
7583 PyArrayObject *tmp21 = NULL ;
7584 PyArrayObject *tmp22 = NULL ;
7585 PyArrayObject *tmp23 = NULL ;
7586 PyArrayObject *tmp24 = NULL ;
7587 PyArrayObject *tmp25 = NULL ;
7588 PyArrayObject *tmp26 = NULL ;
7589 PyArrayObject *tmp27 = NULL ;
7590 PyArrayObject *tmp28 = NULL ;
7591 PyArrayObject *tmp29 = NULL ;
7592 PyArrayObject *tmp30 = NULL ;
7593 PyArrayObject *tmp31 = NULL ;
7594 PyObject *swig_obj[28] ;
7595
7596 arg1 = &temp1;
7597 arg2 = &temp2;
7598 if (!SWIG_Python_UnpackTuple(args, "pllegend", 28, 28, swig_obj)) SWIG_fail;
7599 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
7600 if (!SWIG_IsOK(ecode3)) {
7601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
7602 }
7603 arg3 = (PLINT)(val3);
7604 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
7605 if (!SWIG_IsOK(ecode4)) {
7606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
7607 }
7608 arg4 = (PLINT)(val4);
7609 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
7610 if (!SWIG_IsOK(ecode5)) {
7611 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
7612 }
7613 arg5 = (PLFLT)(val5);
7614 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
7615 if (!SWIG_IsOK(ecode6)) {
7616 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
7617 }
7618 arg6 = (PLFLT)(val6);
7619 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
7620 if (!SWIG_IsOK(ecode7)) {
7621 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
7622 }
7623 arg7 = (PLFLT)(val7);
7624 ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
7625 if (!SWIG_IsOK(ecode8)) {
7626 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
7627 }
7628 arg8 = (PLINT)(val8);
7629 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
7630 if (!SWIG_IsOK(ecode9)) {
7631 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
7632 }
7633 arg9 = (PLINT)(val9);
7634 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
7635 if (!SWIG_IsOK(ecode10)) {
7636 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
7637 }
7638 arg10 = (PLINT)(val10);
7639 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
7640 if (!SWIG_IsOK(ecode11)) {
7641 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
7642 }
7643 arg11 = (PLINT)(val11);
7644 ecode12 = SWIG_AsVal_int(swig_obj[9], &val12);
7645 if (!SWIG_IsOK(ecode12)) {
7646 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
7647 }
7648 arg12 = (PLINT)(val12);
7649 {
7650 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[10], NPY_PLINT, 1, 1 );
7651 if ( tmp13 == NULL )
7652 return NULL;
7653 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7654 arg14 = (PLINT *) PyArray_DATA( tmp13 );
7655 }
7656 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
7657 if (!SWIG_IsOK(ecode15)) {
7658 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
7659 }
7660 arg15 = (PLFLT)(val15);
7661 ecode16 = SWIG_AsVal_double(swig_obj[12], &val16);
7662 if (!SWIG_IsOK(ecode16)) {
7663 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
7664 }
7665 arg16 = (PLFLT)(val16);
7666 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
7667 if (!SWIG_IsOK(ecode17)) {
7668 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
7669 }
7670 arg17 = (PLFLT)(val17);
7671 ecode18 = SWIG_AsVal_double(swig_obj[14], &val18);
7672 if (!SWIG_IsOK(ecode18)) {
7673 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
7674 }
7675 arg18 = (PLFLT)(val18);
7676 {
7677 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[15], NPY_PLINT, 1, 1 );
7678 if ( tmp19 == NULL )
7679 return NULL;
7680 if ( PyArray_DIMS( tmp19 )[0] != Alen )
7681 {
7682 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7683 return NULL;
7684 }
7685 arg19 = (PLINT *) PyArray_DATA( tmp19 );
7686 }
7687 {
7688 int i;
7689 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[16], NPY_STRING, 1, 1 );
7690 if ( tmp20 == NULL )
7691 return NULL;
7692 if ( PyArray_DIMS( tmp20 )[0] != Alen )
7693 {
7694 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7695 return NULL;
7696 }
7697 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
7698 for ( i = 0; i < Alen; i++ )
7699 {
7700 arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
7701 if ( arg20[i] == NULL )
7702 {
7703 free( arg20 );
7704 return NULL;
7705 }
7706 }
7707 }
7708 {
7709 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
7710 if ( tmp21 == NULL )
7711 return NULL;
7712 if ( PyArray_DIMS( tmp21 )[0] != Alen )
7713 {
7714 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7715 return NULL;
7716 }
7717 arg21 = (PLINT *) PyArray_DATA( tmp21 );
7718 }
7719 {
7720 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
7721 if ( tmp22 == NULL )
7722 return NULL;
7723 if ( PyArray_DIMS( tmp22 )[0] != Alen )
7724 {
7725 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7726 return NULL;
7727 }
7728 arg22 = (PLINT *) PyArray_DATA( tmp22 );
7729 }
7730 {
7731 if ( swig_obj[19] != Py_None )
7732 {
7733 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 1, 1 );
7734 if ( tmp23 == NULL )
7735 return NULL;
7736 if ( PyArray_DIMS( tmp23 )[0] != Alen )
7737 {
7738 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7739 return NULL;
7740 }
7741 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
7742 }
7743 else
7744 {
7745 arg23 = NULL;
7746 }
7747 }
7748 {
7749 if ( swig_obj[20] != Py_None )
7750 {
7751 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[20], NPY_PLFLT, 1, 1 );
7752 if ( tmp24 == NULL )
7753 return NULL;
7754 if ( PyArray_DIMS( tmp24 )[0] != Alen )
7755 {
7756 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7757 return NULL;
7758 }
7759 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
7760 }
7761 else
7762 {
7763 arg24 = NULL;
7764 }
7765 }
7766 {
7767 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[21], NPY_PLINT, 1, 1 );
7768 if ( tmp25 == NULL )
7769 return NULL;
7770 if ( PyArray_DIMS( tmp25 )[0] != Alen )
7771 {
7772 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7773 return NULL;
7774 }
7775 arg25 = (PLINT *) PyArray_DATA( tmp25 );
7776 }
7777 {
7778 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[22], NPY_PLINT, 1, 1 );
7779 if ( tmp26 == NULL )
7780 return NULL;
7781 if ( PyArray_DIMS( tmp26 )[0] != Alen )
7782 {
7783 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7784 return NULL;
7785 }
7786 arg26 = (PLINT *) PyArray_DATA( tmp26 );
7787 }
7788 {
7789 if ( swig_obj[23] != Py_None )
7790 {
7791 tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[23], NPY_PLFLT, 1, 1 );
7792 if ( tmp27 == NULL )
7793 return NULL;
7794 if ( PyArray_DIMS( tmp27 )[0] != Alen )
7795 {
7796 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7797 return NULL;
7798 }
7799 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
7800 }
7801 else
7802 {
7803 arg27 = NULL;
7804 }
7805 }
7806 {
7807 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[24], NPY_PLINT, 1, 1 );
7808 if ( tmp28 == NULL )
7809 return NULL;
7810 if ( PyArray_DIMS( tmp28 )[0] != Alen )
7811 {
7812 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7813 return NULL;
7814 }
7815 arg28 = (PLINT *) PyArray_DATA( tmp28 );
7816 }
7817 {
7818 if ( swig_obj[25] != Py_None )
7819 {
7820 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[25], NPY_PLFLT, 1, 1 );
7821 if ( tmp29 == NULL )
7822 return NULL;
7823 if ( PyArray_DIMS( tmp29 )[0] != Alen )
7824 {
7825 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7826 return NULL;
7827 }
7828 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
7829 }
7830 else
7831 {
7832 arg29 = NULL;
7833 }
7834 }
7835 {
7836 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[26], NPY_PLINT, 1, 1 );
7837 if ( tmp30 == NULL )
7838 return NULL;
7839 if ( PyArray_DIMS( tmp30 )[0] != Alen )
7840 {
7841 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7842 return NULL;
7843 }
7844 arg30 = (PLINT *) PyArray_DATA( tmp30 );
7845 }
7846 {
7847 int i;
7848 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[27], NPY_STRING, 1, 1 );
7849 if ( tmp31 == NULL )
7850 return NULL;
7851 if ( PyArray_DIMS( tmp31 )[0] != Alen )
7852 {
7853 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7854 return NULL;
7855 }
7856 arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
7857 for ( i = 0; i < Alen; i++ )
7858 {
7859 arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
7860 if ( arg31[i] == NULL )
7861 {
7862 free( arg31 );
7863 return NULL;
7864 }
7865 }
7866 }
7867 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);
7868 resultobj = SWIG_Py_Void();
7869 if (SWIG_IsTmpObj(res1)) {
7870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7871 } else {
7872 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7874 }
7875 if (SWIG_IsTmpObj(res2)) {
7876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7877 } else {
7878 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7880 }
7881 {
7882 Py_CLEAR( tmp13 );
7883 }
7884 {
7885 Py_CLEAR( tmp19 );
7886 }
7887 {
7888 Py_CLEAR( tmp20 ); free( arg20 );
7889 }
7890 {
7891 Py_CLEAR( tmp21 );
7892 }
7893 {
7894 Py_CLEAR( tmp22 );
7895 }
7896 {
7897 Py_CLEAR( tmp23 );
7898 }
7899 {
7900 Py_CLEAR( tmp24 );
7901 }
7902 {
7903 Py_CLEAR( tmp25 );
7904 }
7905 {
7906 Py_CLEAR( tmp26 );
7907 }
7908 {
7909 Py_CLEAR( tmp27 );
7910 }
7911 {
7912 Py_CLEAR( tmp28 );
7913 }
7914 {
7915 Py_CLEAR( tmp29 );
7916 }
7917 {
7918 Py_CLEAR( tmp30 );
7919 }
7920 {
7921 Py_CLEAR( tmp31 ); free( arg31 );
7922 }
7923 return resultobj;
7924fail:
7925 {
7926 Py_CLEAR( tmp13 );
7927 }
7928 {
7929 Py_CLEAR( tmp19 );
7930 }
7931 {
7932 Py_CLEAR( tmp20 ); free( arg20 );
7933 }
7934 {
7935 Py_CLEAR( tmp21 );
7936 }
7937 {
7938 Py_CLEAR( tmp22 );
7939 }
7940 {
7941 Py_CLEAR( tmp23 );
7942 }
7943 {
7944 Py_CLEAR( tmp24 );
7945 }
7946 {
7947 Py_CLEAR( tmp25 );
7948 }
7949 {
7950 Py_CLEAR( tmp26 );
7951 }
7952 {
7953 Py_CLEAR( tmp27 );
7954 }
7955 {
7956 Py_CLEAR( tmp28 );
7957 }
7958 {
7959 Py_CLEAR( tmp29 );
7960 }
7961 {
7962 Py_CLEAR( tmp30 );
7963 }
7964 {
7965 Py_CLEAR( tmp31 ); free( arg31 );
7966 }
7967 return NULL;
7968}
7969
7970
7971SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7972 PyObject *resultobj = 0;
7973 PLFLT *arg1 = (PLFLT *) 0 ;
7974 PLFLT *arg2 = (PLFLT *) 0 ;
7975 PLINT arg3 ;
7976 PLINT arg4 ;
7977 PLFLT arg5 ;
7978 PLFLT arg6 ;
7979 PLFLT arg7 ;
7980 PLFLT arg8 ;
7981 PLINT arg9 ;
7982 PLINT arg10 ;
7983 PLINT arg11 ;
7984 PLFLT arg12 ;
7985 PLFLT arg13 ;
7986 PLINT arg14 ;
7987 PLFLT arg15 ;
7988 PLINT arg16 ;
7989 PLINT *arg17 = (PLINT *) 0 ;
7990 char **arg18 = (char **) 0 ;
7991 PLINT arg19 ;
7992 char **arg20 = (char **) 0 ;
7993 PLFLT *arg21 = (PLFLT *) 0 ;
7994 PLINT *arg22 = (PLINT *) 0 ;
7995 PLINT *arg23 = (PLINT *) 0 ;
7996 PLFLT **arg24 = (PLFLT **) 0 ;
7997 PLFLT temp1 ;
7998 int res1 = SWIG_TMPOBJ ;
7999 PLFLT temp2 ;
8000 int res2 = SWIG_TMPOBJ ;
8001 int val3 ;
8002 int ecode3 = 0 ;
8003 int val4 ;
8004 int ecode4 = 0 ;
8005 double val5 ;
8006 int ecode5 = 0 ;
8007 double val6 ;
8008 int ecode6 = 0 ;
8009 double val7 ;
8010 int ecode7 = 0 ;
8011 double val8 ;
8012 int ecode8 = 0 ;
8013 int val9 ;
8014 int ecode9 = 0 ;
8015 int val10 ;
8016 int ecode10 = 0 ;
8017 int val11 ;
8018 int ecode11 = 0 ;
8019 double val12 ;
8020 int ecode12 = 0 ;
8021 double val13 ;
8022 int ecode13 = 0 ;
8023 int val14 ;
8024 int ecode14 = 0 ;
8025 double val15 ;
8026 int ecode15 = 0 ;
8027 PyArrayObject *tmp16 = NULL ;
8028 PyArrayObject *tmp18 = NULL ;
8029 PyArrayObject *tmp19 = NULL ;
8030 PyArrayObject *tmp21 = NULL ;
8031 PyArrayObject *tmp22 = NULL ;
8032 PyArrayObject *tmp23 = NULL ;
8033 PyArrayObject *tmp24 = NULL ;
8034 PyObject *swig_obj[20] ;
8035
8036 arg1 = &temp1;
8037 arg2 = &temp2;
8038 if (!SWIG_Python_UnpackTuple(args, "plcolorbar", 20, 20, swig_obj)) SWIG_fail;
8039 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8040 if (!SWIG_IsOK(ecode3)) {
8041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8042 }
8043 arg3 = (PLINT)(val3);
8044 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8045 if (!SWIG_IsOK(ecode4)) {
8046 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8047 }
8048 arg4 = (PLINT)(val4);
8049 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8050 if (!SWIG_IsOK(ecode5)) {
8051 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8052 }
8053 arg5 = (PLFLT)(val5);
8054 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8055 if (!SWIG_IsOK(ecode6)) {
8056 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8057 }
8058 arg6 = (PLFLT)(val6);
8059 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8060 if (!SWIG_IsOK(ecode7)) {
8061 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8062 }
8063 arg7 = (PLFLT)(val7);
8064 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
8065 if (!SWIG_IsOK(ecode8)) {
8066 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8067 }
8068 arg8 = (PLFLT)(val8);
8069 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8070 if (!SWIG_IsOK(ecode9)) {
8071 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8072 }
8073 arg9 = (PLINT)(val9);
8074 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8075 if (!SWIG_IsOK(ecode10)) {
8076 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8077 }
8078 arg10 = (PLINT)(val10);
8079 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8080 if (!SWIG_IsOK(ecode11)) {
8081 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8082 }
8083 arg11 = (PLINT)(val11);
8084 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
8085 if (!SWIG_IsOK(ecode12)) {
8086 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8087 }
8088 arg12 = (PLFLT)(val12);
8089 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
8090 if (!SWIG_IsOK(ecode13)) {
8091 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8092 }
8093 arg13 = (PLFLT)(val13);
8094 ecode14 = SWIG_AsVal_int(swig_obj[11], &val14);
8095 if (!SWIG_IsOK(ecode14)) {
8096 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8097 }
8098 arg14 = (PLINT)(val14);
8099 ecode15 = SWIG_AsVal_double(swig_obj[12], &val15);
8100 if (!SWIG_IsOK(ecode15)) {
8101 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8102 }
8103 arg15 = (PLFLT)(val15);
8104 {
8105 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
8106 if ( tmp16 == NULL )
8107 return NULL;
8108 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8109 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8110 }
8111 {
8112 int i;
8113 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[14], NPY_STRING, 1, 1 );
8114 if ( tmp18 == NULL )
8115 return NULL;
8116 if ( PyArray_DIMS( tmp18 )[0] != Alen )
8117 {
8118 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8119 return NULL;
8120 }
8121 arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8122 for ( i = 0; i < Alen; i++ )
8123 {
8124 arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8125 if ( arg18[i] == NULL )
8126 {
8127 free( arg18 );
8128 return NULL;
8129 }
8130 }
8131 }
8132 {
8133 int i;
8134 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[15], NPY_STRING, 1, 1 );
8135 if ( tmp19 == NULL )
8136 return NULL;
8137 Alen = PyArray_DIMS( tmp19 )[0];
8138 arg19 = Alen;
8139 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8140 for ( i = 0; i < Alen; i++ )
8141 {
8142 arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8143 if ( arg20[i] == NULL )
8144 {
8145 free( arg20 );
8146 return NULL;
8147 }
8148 }
8149 }
8150 {
8151 tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[16], NPY_PLFLT, 1, 1 );
8152 if ( tmp21 == NULL )
8153 return NULL;
8154 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8155 {
8156 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8157 return NULL;
8158 }
8159 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8160 }
8161 {
8162 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8163 if ( tmp22 == NULL )
8164 return NULL;
8165 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8166 {
8167 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8168 return NULL;
8169 }
8170 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8171 }
8172 {
8173 int i;
8174 tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8175 if ( tmp23 == NULL )
8176 return NULL;
8177 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8178 {
8179 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8180 return NULL;
8181 }
8182 Xlen = PyArray_DIMS( tmp23 )[0];
8183 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8184 Ylen = -1;
8185 for ( i = 0; i < Xlen; i++ )
8186 if ( arg23[i] > Ylen )
8187 Ylen = arg23[i];
8188 }
8189 {
8190 int i, size;
8191 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 2, 2 );
8192 if ( tmp24 == NULL )
8193 return NULL;
8194 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8195 {
8196 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8197 return NULL;
8198 }
8199 size = Ylen;
8200 arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8201 for ( i = 0; i < Xlen; i++ )
8202 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8203 }
8204 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);
8205 resultobj = SWIG_Py_Void();
8206 if (SWIG_IsTmpObj(res1)) {
8207 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8208 } else {
8209 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8210 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8211 }
8212 if (SWIG_IsTmpObj(res2)) {
8213 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8214 } else {
8215 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8216 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8217 }
8218 {
8219 Py_CLEAR( tmp16 );
8220 }
8221 {
8222 Py_CLEAR( tmp18 ); free( arg18 );
8223 }
8224 {
8225 Py_CLEAR( tmp19 ); free( arg20 );
8226 }
8227 {
8228 Py_CLEAR( tmp21 );
8229 }
8230 {
8231 Py_CLEAR( tmp22 );
8232 }
8233 {
8234 Py_CLEAR( tmp23 );
8235 }
8236 {
8237 Py_CLEAR( tmp24 );
8238 free( arg24 );
8239 }
8240 return resultobj;
8241fail:
8242 {
8243 Py_CLEAR( tmp16 );
8244 }
8245 {
8246 Py_CLEAR( tmp18 ); free( arg18 );
8247 }
8248 {
8249 Py_CLEAR( tmp19 ); free( arg20 );
8250 }
8251 {
8252 Py_CLEAR( tmp21 );
8253 }
8254 {
8255 Py_CLEAR( tmp22 );
8256 }
8257 {
8258 Py_CLEAR( tmp23 );
8259 }
8260 {
8261 Py_CLEAR( tmp24 );
8262 free( arg24 );
8263 }
8264 return NULL;
8265}
8266
8267
8268SWIGINTERN PyObject *_wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8269 PyObject *resultobj = 0;
8270 PLFLT arg1 ;
8271 PLFLT arg2 ;
8272 PLFLT arg3 ;
8273 double val1 ;
8274 int ecode1 = 0 ;
8275 double val2 ;
8276 int ecode2 = 0 ;
8277 double val3 ;
8278 int ecode3 = 0 ;
8279 PyObject *swig_obj[3] ;
8280
8281 if (!SWIG_Python_UnpackTuple(args, "pllightsource", 3, 3, swig_obj)) SWIG_fail;
8282 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8283 if (!SWIG_IsOK(ecode1)) {
8284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8285 }
8286 arg1 = (PLFLT)(val1);
8287 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8288 if (!SWIG_IsOK(ecode2)) {
8289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8290 }
8291 arg2 = (PLFLT)(val2);
8292 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8293 if (!SWIG_IsOK(ecode3)) {
8294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8295 }
8296 arg3 = (PLFLT)(val3);
8297 pllightsource(arg1,arg2,arg3);
8298 resultobj = SWIG_Py_Void();
8299 return resultobj;
8300fail:
8301 return NULL;
8302}
8303
8304
8305SWIGINTERN PyObject *_wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8306 PyObject *resultobj = 0;
8307 PLINT arg1 ;
8308 PLFLT *arg2 = (PLFLT *) 0 ;
8309 PLFLT *arg3 = (PLFLT *) 0 ;
8310 PyArrayObject *tmp1 = NULL ;
8311 PyArrayObject *tmp3 = NULL ;
8312 PyObject *swig_obj[2] ;
8313
8314 if (!SWIG_Python_UnpackTuple(args, "plline", 2, 2, swig_obj)) SWIG_fail;
8315 {
8316 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8317 if ( tmp1 == NULL )
8318 return NULL;
8319 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8320 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8321 }
8322 {
8323 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8324 if ( tmp3 == NULL )
8325 return NULL;
8326 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8327 {
8328 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8329 return NULL;
8330 }
8331 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8332 }
8333 plline(arg1,(double const *)arg2,(double const *)arg3);
8334 resultobj = SWIG_Py_Void();
8335 {
8336 Py_CLEAR( tmp1 );
8337 }
8338 {
8339 Py_CLEAR( tmp3 );
8340 }
8341 return resultobj;
8342fail:
8343 {
8344 Py_CLEAR( tmp1 );
8345 }
8346 {
8347 Py_CLEAR( tmp3 );
8348 }
8349 return NULL;
8350}
8351
8352
8353SWIGINTERN PyObject *_wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8354 PyObject *resultobj = 0;
8355 PLINT arg1 ;
8356 PLFLT *arg2 = (PLFLT *) 0 ;
8357 PLFLT *arg3 = (PLFLT *) 0 ;
8358 PLFLT *arg4 = (PLFLT *) 0 ;
8359 PyArrayObject *tmp1 = NULL ;
8360 PyArrayObject *tmp3 = NULL ;
8361 PyArrayObject *tmp4 = NULL ;
8362 PyObject *swig_obj[3] ;
8363
8364 if (!SWIG_Python_UnpackTuple(args, "plline3", 3, 3, swig_obj)) SWIG_fail;
8365 {
8366 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8367 if ( tmp1 == NULL )
8368 return NULL;
8369 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8370 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8371 }
8372 {
8373 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8374 if ( tmp3 == NULL )
8375 return NULL;
8376 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8377 {
8378 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8379 return NULL;
8380 }
8381 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8382 }
8383 {
8384 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
8385 if ( tmp4 == NULL )
8386 return NULL;
8387 if ( PyArray_DIMS( tmp4 )[0] != Alen )
8388 {
8389 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8390 return NULL;
8391 }
8392 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8393 }
8394 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8395 resultobj = SWIG_Py_Void();
8396 {
8397 Py_CLEAR( tmp1 );
8398 }
8399 {
8400 Py_CLEAR( tmp3 );
8401 }
8402 {
8403 Py_CLEAR( tmp4 );
8404 }
8405 return resultobj;
8406fail:
8407 {
8408 Py_CLEAR( tmp1 );
8409 }
8410 {
8411 Py_CLEAR( tmp3 );
8412 }
8413 {
8414 Py_CLEAR( tmp4 );
8415 }
8416 return NULL;
8417}
8418
8419
8420SWIGINTERN PyObject *_wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8421 PyObject *resultobj = 0;
8422 PLINT arg1 ;
8423 int val1 ;
8424 int ecode1 = 0 ;
8425 PyObject *swig_obj[1] ;
8426
8427 if (!args) SWIG_fail;
8428 swig_obj[0] = args;
8429 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
8430 if (!SWIG_IsOK(ecode1)) {
8431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8432 }
8433 arg1 = (PLINT)(val1);
8434 pllsty(arg1);
8435 resultobj = SWIG_Py_Void();
8436 return resultobj;
8437fail:
8438 return NULL;
8439}
8440
8441
8442SWIGINTERN PyObject *_wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8443 PyObject *resultobj = 0;
8444 PLFLT *arg1 = (PLFLT *) 0 ;
8445 PLFLT *arg2 = (PLFLT *) 0 ;
8446 PLFLT **arg3 = (PLFLT **) 0 ;
8447 PLINT arg4 ;
8448 PLINT arg5 ;
8449 PLINT arg6 ;
8450 PyArrayObject *tmp1 = NULL ;
8451 PyArrayObject *tmp2 = NULL ;
8452 PyArrayObject *tmp3 = NULL ;
8453 int val6 ;
8454 int ecode6 = 0 ;
8455 PyObject *swig_obj[4] ;
8456
8457 if (!SWIG_Python_UnpackTuple(args, "plmesh", 4, 4, swig_obj)) SWIG_fail;
8458 {
8459 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8460 if ( tmp1 == NULL )
8461 return NULL;
8462 Xlen = PyArray_DIMS( tmp1 )[0];
8463 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8464 }
8465 {
8466 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8467 if ( tmp2 == NULL )
8468 return NULL;
8469 Ylen = PyArray_DIMS( tmp2 )[0];
8470 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8471 }
8472 {
8473 int i, size;
8474 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8475 if ( tmp3 == NULL )
8476 return NULL;
8477 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8478 {
8479 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8480 return NULL;
8481 }
8482 arg4 = PyArray_DIMS( tmp3 )[0];
8483 arg5 = PyArray_DIMS( tmp3 )[1];
8484 size = arg5;
8485 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8486 for ( i = 0; i < arg4; i++ )
8487 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8488 }
8489 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8490 if (!SWIG_IsOK(ecode6)) {
8491 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8492 }
8493 arg6 = (PLINT)(val6);
8494 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8495 resultobj = SWIG_Py_Void();
8496 {
8497 Py_CLEAR( tmp1 );
8498 }
8499 {
8500 Py_CLEAR( tmp2 );
8501 }
8502 {
8503 Py_CLEAR( tmp3 );
8504 free( arg3 );
8505 }
8506 return resultobj;
8507fail:
8508 {
8509 Py_CLEAR( tmp1 );
8510 }
8511 {
8512 Py_CLEAR( tmp2 );
8513 }
8514 {
8515 Py_CLEAR( tmp3 );
8516 free( arg3 );
8517 }
8518 return NULL;
8519}
8520
8521
8522SWIGINTERN PyObject *_wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8523 PyObject *resultobj = 0;
8524 PLFLT *arg1 = (PLFLT *) 0 ;
8525 PLFLT *arg2 = (PLFLT *) 0 ;
8526 PLFLT **arg3 = (PLFLT **) 0 ;
8527 PLINT arg4 ;
8528 PLINT arg5 ;
8529 PLINT arg6 ;
8530 PLFLT *arg7 = (PLFLT *) 0 ;
8531 PLINT arg8 ;
8532 PyArrayObject *tmp1 = NULL ;
8533 PyArrayObject *tmp2 = NULL ;
8534 PyArrayObject *tmp3 = NULL ;
8535 int val6 ;
8536 int ecode6 = 0 ;
8537 PyArrayObject *tmp7 = NULL ;
8538 PyObject *swig_obj[5] ;
8539
8540 if (!SWIG_Python_UnpackTuple(args, "plmeshc", 5, 5, swig_obj)) SWIG_fail;
8541 {
8542 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8543 if ( tmp1 == NULL )
8544 return NULL;
8545 Xlen = PyArray_DIMS( tmp1 )[0];
8546 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8547 }
8548 {
8549 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8550 if ( tmp2 == NULL )
8551 return NULL;
8552 Ylen = PyArray_DIMS( tmp2 )[0];
8553 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8554 }
8555 {
8556 int i, size;
8557 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8558 if ( tmp3 == NULL )
8559 return NULL;
8560 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8561 {
8562 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8563 return NULL;
8564 }
8565 arg4 = PyArray_DIMS( tmp3 )[0];
8566 arg5 = PyArray_DIMS( tmp3 )[1];
8567 size = arg5;
8568 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8569 for ( i = 0; i < arg4; i++ )
8570 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8571 }
8572 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8573 if (!SWIG_IsOK(ecode6)) {
8574 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
8575 }
8576 arg6 = (PLINT)(val6);
8577 {
8578 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
8579 if ( tmp7 == NULL )
8580 return NULL;
8581 arg8 = PyArray_DIMS( tmp7 )[0];
8582 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8583 }
8584 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8585 resultobj = SWIG_Py_Void();
8586 {
8587 Py_CLEAR( tmp1 );
8588 }
8589 {
8590 Py_CLEAR( tmp2 );
8591 }
8592 {
8593 Py_CLEAR( tmp3 );
8594 free( arg3 );
8595 }
8596 {
8597 Py_CLEAR( tmp7 );
8598 }
8599 return resultobj;
8600fail:
8601 {
8602 Py_CLEAR( tmp1 );
8603 }
8604 {
8605 Py_CLEAR( tmp2 );
8606 }
8607 {
8608 Py_CLEAR( tmp3 );
8609 free( arg3 );
8610 }
8611 {
8612 Py_CLEAR( tmp7 );
8613 }
8614 return NULL;
8615}
8616
8617
8618SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8619 PyObject *resultobj = 0;
8620 PLINT *arg1 = (PLINT *) 0 ;
8621 PLINT temp1 ;
8622 int res1 = SWIG_TMPOBJ ;
8623
8624 arg1 = &temp1;
8625 if (!SWIG_Python_UnpackTuple(args, "plmkstrm", 0, 0, 0)) SWIG_fail;
8626 plmkstrm(arg1);
8627 resultobj = SWIG_Py_Void();
8628 if (SWIG_IsTmpObj(res1)) {
8629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
8630 } else {
8631 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8633 }
8634 return resultobj;
8635fail:
8636 return NULL;
8637}
8638
8639
8640SWIGINTERN PyObject *_wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8641 PyObject *resultobj = 0;
8642 char *arg1 = (char *) 0 ;
8643 PLFLT arg2 ;
8644 PLFLT arg3 ;
8645 PLFLT arg4 ;
8646 char *arg5 = (char *) 0 ;
8647 int res1 ;
8648 char *buf1 = 0 ;
8649 int alloc1 = 0 ;
8650 double val2 ;
8651 int ecode2 = 0 ;
8652 double val3 ;
8653 int ecode3 = 0 ;
8654 double val4 ;
8655 int ecode4 = 0 ;
8656 int res5 ;
8657 char *buf5 = 0 ;
8658 int alloc5 = 0 ;
8659 PyObject *swig_obj[5] ;
8660
8661 if (!SWIG_Python_UnpackTuple(args, "plmtex", 5, 5, swig_obj)) SWIG_fail;
8662 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8663 if (!SWIG_IsOK(res1)) {
8664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
8665 }
8666 arg1 = (char *)(buf1);
8667 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8668 if (!SWIG_IsOK(ecode2)) {
8669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
8670 }
8671 arg2 = (PLFLT)(val2);
8672 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8673 if (!SWIG_IsOK(ecode3)) {
8674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
8675 }
8676 arg3 = (PLFLT)(val3);
8677 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8678 if (!SWIG_IsOK(ecode4)) {
8679 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
8680 }
8681 arg4 = (PLFLT)(val4);
8682 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
8683 if (!SWIG_IsOK(res5)) {
8684 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
8685 }
8686 arg5 = (char *)(buf5);
8687 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
8688 resultobj = SWIG_Py_Void();
8689 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8690 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8691 return resultobj;
8692fail:
8693 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8694 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8695 return NULL;
8696}
8697
8698
8699SWIGINTERN PyObject *_wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8700 PyObject *resultobj = 0;
8701 char *arg1 = (char *) 0 ;
8702 PLFLT arg2 ;
8703 PLFLT arg3 ;
8704 PLFLT arg4 ;
8705 char *arg5 = (char *) 0 ;
8706 int res1 ;
8707 char *buf1 = 0 ;
8708 int alloc1 = 0 ;
8709 double val2 ;
8710 int ecode2 = 0 ;
8711 double val3 ;
8712 int ecode3 = 0 ;
8713 double val4 ;
8714 int ecode4 = 0 ;
8715 int res5 ;
8716 char *buf5 = 0 ;
8717 int alloc5 = 0 ;
8718 PyObject *swig_obj[5] ;
8719
8720 if (!SWIG_Python_UnpackTuple(args, "plmtex3", 5, 5, swig_obj)) SWIG_fail;
8721 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8722 if (!SWIG_IsOK(res1)) {
8723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
8724 }
8725 arg1 = (char *)(buf1);
8726 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8727 if (!SWIG_IsOK(ecode2)) {
8728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
8729 }
8730 arg2 = (PLFLT)(val2);
8731 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8732 if (!SWIG_IsOK(ecode3)) {
8733 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
8734 }
8735 arg3 = (PLFLT)(val3);
8736 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8737 if (!SWIG_IsOK(ecode4)) {
8738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
8739 }
8740 arg4 = (PLFLT)(val4);
8741 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
8742 if (!SWIG_IsOK(res5)) {
8743 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
8744 }
8745 arg5 = (char *)(buf5);
8746 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
8747 resultobj = SWIG_Py_Void();
8748 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8749 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8750 return resultobj;
8751fail:
8752 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8753 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
8754 return NULL;
8755}
8756
8757
8758SWIGINTERN PyObject *_wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8759 PyObject *resultobj = 0;
8760 PLFLT *arg1 = (PLFLT *) 0 ;
8761 PLFLT *arg2 = (PLFLT *) 0 ;
8762 PLFLT **arg3 = (PLFLT **) 0 ;
8763 PLINT arg4 ;
8764 PLINT arg5 ;
8765 PLINT arg6 ;
8766 PLBOOL arg7 ;
8767 PyArrayObject *tmp1 = NULL ;
8768 PyArrayObject *tmp2 = NULL ;
8769 PyArrayObject *tmp3 = NULL ;
8770 int val6 ;
8771 int ecode6 = 0 ;
8772 int val7 ;
8773 int ecode7 = 0 ;
8774 PyObject *swig_obj[5] ;
8775
8776 if (!SWIG_Python_UnpackTuple(args, "plot3d", 5, 5, swig_obj)) SWIG_fail;
8777 {
8778 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8779 if ( tmp1 == NULL )
8780 return NULL;
8781 Xlen = PyArray_DIMS( tmp1 )[0];
8782 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8783 }
8784 {
8785 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8786 if ( tmp2 == NULL )
8787 return NULL;
8788 Ylen = PyArray_DIMS( tmp2 )[0];
8789 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8790 }
8791 {
8792 int i, size;
8793 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8794 if ( tmp3 == NULL )
8795 return NULL;
8796 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8797 {
8798 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8799 return NULL;
8800 }
8801 arg4 = PyArray_DIMS( tmp3 )[0];
8802 arg5 = PyArray_DIMS( tmp3 )[1];
8803 size = arg5;
8804 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8805 for ( i = 0; i < arg4; i++ )
8806 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8807 }
8808 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8809 if (!SWIG_IsOK(ecode6)) {
8810 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
8811 }
8812 arg6 = (PLINT)(val6);
8813 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
8814 if (!SWIG_IsOK(ecode7)) {
8815 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
8816 }
8817 arg7 = (PLBOOL)(val7);
8818 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
8819 resultobj = SWIG_Py_Void();
8820 {
8821 Py_CLEAR( tmp1 );
8822 }
8823 {
8824 Py_CLEAR( tmp2 );
8825 }
8826 {
8827 Py_CLEAR( tmp3 );
8828 free( arg3 );
8829 }
8830 return resultobj;
8831fail:
8832 {
8833 Py_CLEAR( tmp1 );
8834 }
8835 {
8836 Py_CLEAR( tmp2 );
8837 }
8838 {
8839 Py_CLEAR( tmp3 );
8840 free( arg3 );
8841 }
8842 return NULL;
8843}
8844
8845
8846SWIGINTERN PyObject *_wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8847 PyObject *resultobj = 0;
8848 PLFLT *arg1 = (PLFLT *) 0 ;
8849 PLFLT *arg2 = (PLFLT *) 0 ;
8850 PLFLT **arg3 = (PLFLT **) 0 ;
8851 PLINT arg4 ;
8852 PLINT arg5 ;
8853 PLINT arg6 ;
8854 PLFLT *arg7 = (PLFLT *) 0 ;
8855 PLINT arg8 ;
8856 PyArrayObject *tmp1 = NULL ;
8857 PyArrayObject *tmp2 = NULL ;
8858 PyArrayObject *tmp3 = NULL ;
8859 int val6 ;
8860 int ecode6 = 0 ;
8861 PyArrayObject *tmp7 = NULL ;
8862 PyObject *swig_obj[5] ;
8863
8864 if (!SWIG_Python_UnpackTuple(args, "plot3dc", 5, 5, swig_obj)) SWIG_fail;
8865 {
8866 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8867 if ( tmp1 == NULL )
8868 return NULL;
8869 Xlen = PyArray_DIMS( tmp1 )[0];
8870 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8871 }
8872 {
8873 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8874 if ( tmp2 == NULL )
8875 return NULL;
8876 Ylen = PyArray_DIMS( tmp2 )[0];
8877 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8878 }
8879 {
8880 int i, size;
8881 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8882 if ( tmp3 == NULL )
8883 return NULL;
8884 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8885 {
8886 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8887 return NULL;
8888 }
8889 arg4 = PyArray_DIMS( tmp3 )[0];
8890 arg5 = PyArray_DIMS( tmp3 )[1];
8891 size = arg5;
8892 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8893 for ( i = 0; i < arg4; i++ )
8894 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8895 }
8896 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8897 if (!SWIG_IsOK(ecode6)) {
8898 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
8899 }
8900 arg6 = (PLINT)(val6);
8901 {
8902 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
8903 if ( tmp7 == NULL )
8904 return NULL;
8905 arg8 = PyArray_DIMS( tmp7 )[0];
8906 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8907 }
8908 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8909 resultobj = SWIG_Py_Void();
8910 {
8911 Py_CLEAR( tmp1 );
8912 }
8913 {
8914 Py_CLEAR( tmp2 );
8915 }
8916 {
8917 Py_CLEAR( tmp3 );
8918 free( arg3 );
8919 }
8920 {
8921 Py_CLEAR( tmp7 );
8922 }
8923 return resultobj;
8924fail:
8925 {
8926 Py_CLEAR( tmp1 );
8927 }
8928 {
8929 Py_CLEAR( tmp2 );
8930 }
8931 {
8932 Py_CLEAR( tmp3 );
8933 free( arg3 );
8934 }
8935 {
8936 Py_CLEAR( tmp7 );
8937 }
8938 return NULL;
8939}
8940
8941
8942SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8943 PyObject *resultobj = 0;
8944 PLFLT *arg1 = (PLFLT *) 0 ;
8945 PLFLT *arg2 = (PLFLT *) 0 ;
8946 PLFLT **arg3 = (PLFLT **) 0 ;
8947 PLINT arg4 ;
8948 PLINT arg5 ;
8949 PLINT arg6 ;
8950 PLFLT *arg7 = (PLFLT *) 0 ;
8951 PLINT arg8 ;
8952 PLINT arg9 ;
8953 PLINT arg10 ;
8954 PLINT *arg11 = (PLINT *) 0 ;
8955 PLINT *arg12 = (PLINT *) 0 ;
8956 PyArrayObject *tmp1 = NULL ;
8957 PyArrayObject *tmp2 = NULL ;
8958 PyArrayObject *tmp3 = NULL ;
8959 int val6 ;
8960 int ecode6 = 0 ;
8961 PyArrayObject *tmp7 = NULL ;
8962 int val9 ;
8963 int ecode9 = 0 ;
8964 PyArrayObject *tmp10 = NULL ;
8965 PyArrayObject *tmp12 = NULL ;
8966 PyObject *swig_obj[8] ;
8967
8968 if (!SWIG_Python_UnpackTuple(args, "plot3dcl", 8, 8, swig_obj)) SWIG_fail;
8969 {
8970 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8971 if ( tmp1 == NULL )
8972 return NULL;
8973 Xlen = PyArray_DIMS( tmp1 )[0];
8974 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8975 }
8976 {
8977 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8978 if ( tmp2 == NULL )
8979 return NULL;
8980 Ylen = PyArray_DIMS( tmp2 )[0];
8981 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8982 }
8983 {
8984 int i, size;
8985 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8986 if ( tmp3 == NULL )
8987 return NULL;
8988 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8989 {
8990 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8991 return NULL;
8992 }
8993 arg4 = PyArray_DIMS( tmp3 )[0];
8994 arg5 = PyArray_DIMS( tmp3 )[1];
8995 size = arg5;
8996 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8997 for ( i = 0; i < arg4; i++ )
8998 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8999 }
9000 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9001 if (!SWIG_IsOK(ecode6)) {
9002 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9003 }
9004 arg6 = (PLINT)(val6);
9005 {
9006 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9007 if ( tmp7 == NULL )
9008 return NULL;
9009 arg8 = PyArray_DIMS( tmp7 )[0];
9010 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9011 }
9012 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9013 if (!SWIG_IsOK(ecode9)) {
9014 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9015 }
9016 arg9 = (PLINT)(val9);
9017 {
9018 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9019 if ( tmp10 == NULL )
9020 return NULL;
9021 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9022 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9023 }
9024 {
9025 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9026 if ( tmp12 == NULL )
9027 return NULL;
9028 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9029 {
9030 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9031 return NULL;
9032 }
9033 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9034 }
9035 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);
9036 resultobj = SWIG_Py_Void();
9037 {
9038 Py_CLEAR( tmp1 );
9039 }
9040 {
9041 Py_CLEAR( tmp2 );
9042 }
9043 {
9044 Py_CLEAR( tmp3 );
9045 free( arg3 );
9046 }
9047 {
9048 Py_CLEAR( tmp7 );
9049 }
9050 {
9051 Py_CLEAR( tmp10 );
9052 }
9053 {
9054 Py_CLEAR( tmp12 );
9055 }
9056 return resultobj;
9057fail:
9058 {
9059 Py_CLEAR( tmp1 );
9060 }
9061 {
9062 Py_CLEAR( tmp2 );
9063 }
9064 {
9065 Py_CLEAR( tmp3 );
9066 free( arg3 );
9067 }
9068 {
9069 Py_CLEAR( tmp7 );
9070 }
9071 {
9072 Py_CLEAR( tmp10 );
9073 }
9074 {
9075 Py_CLEAR( tmp12 );
9076 }
9077 return NULL;
9078}
9079
9080
9081SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9082 PyObject *resultobj = 0;
9083 PLFLT *arg1 = (PLFLT *) 0 ;
9084 PLFLT *arg2 = (PLFLT *) 0 ;
9085 PLFLT **arg3 = (PLFLT **) 0 ;
9086 PLINT arg4 ;
9087 PLINT arg5 ;
9088 PLINT arg6 ;
9089 PLFLT *arg7 = (PLFLT *) 0 ;
9090 PLINT arg8 ;
9091 PyArrayObject *tmp1 = NULL ;
9092 PyArrayObject *tmp2 = NULL ;
9093 PyArrayObject *tmp3 = NULL ;
9094 int val6 ;
9095 int ecode6 = 0 ;
9096 PyArrayObject *tmp7 = NULL ;
9097 PyObject *swig_obj[5] ;
9098
9099 if (!SWIG_Python_UnpackTuple(args, "plsurf3d", 5, 5, swig_obj)) SWIG_fail;
9100 {
9101 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9102 if ( tmp1 == NULL )
9103 return NULL;
9104 Xlen = PyArray_DIMS( tmp1 )[0];
9105 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9106 }
9107 {
9108 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9109 if ( tmp2 == NULL )
9110 return NULL;
9111 Ylen = PyArray_DIMS( tmp2 )[0];
9112 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9113 }
9114 {
9115 int i, size;
9116 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9117 if ( tmp3 == NULL )
9118 return NULL;
9119 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9120 {
9121 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9122 return NULL;
9123 }
9124 arg4 = PyArray_DIMS( tmp3 )[0];
9125 arg5 = PyArray_DIMS( tmp3 )[1];
9126 size = arg5;
9127 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9128 for ( i = 0; i < arg4; i++ )
9129 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9130 }
9131 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9132 if (!SWIG_IsOK(ecode6)) {
9133 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9134 }
9135 arg6 = (PLINT)(val6);
9136 {
9137 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9138 if ( tmp7 == NULL )
9139 return NULL;
9140 arg8 = PyArray_DIMS( tmp7 )[0];
9141 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9142 }
9143 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9144 resultobj = SWIG_Py_Void();
9145 {
9146 Py_CLEAR( tmp1 );
9147 }
9148 {
9149 Py_CLEAR( tmp2 );
9150 }
9151 {
9152 Py_CLEAR( tmp3 );
9153 free( arg3 );
9154 }
9155 {
9156 Py_CLEAR( tmp7 );
9157 }
9158 return resultobj;
9159fail:
9160 {
9161 Py_CLEAR( tmp1 );
9162 }
9163 {
9164 Py_CLEAR( tmp2 );
9165 }
9166 {
9167 Py_CLEAR( tmp3 );
9168 free( arg3 );
9169 }
9170 {
9171 Py_CLEAR( tmp7 );
9172 }
9173 return NULL;
9174}
9175
9176
9177SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9178 PyObject *resultobj = 0;
9179 PLFLT *arg1 = (PLFLT *) 0 ;
9180 PLFLT *arg2 = (PLFLT *) 0 ;
9181 PLFLT **arg3 = (PLFLT **) 0 ;
9182 PLINT arg4 ;
9183 PLINT arg5 ;
9184 PLINT arg6 ;
9185 PLFLT *arg7 = (PLFLT *) 0 ;
9186 PLINT arg8 ;
9187 PLINT arg9 ;
9188 PLINT arg10 ;
9189 PLINT *arg11 = (PLINT *) 0 ;
9190 PLINT *arg12 = (PLINT *) 0 ;
9191 PyArrayObject *tmp1 = NULL ;
9192 PyArrayObject *tmp2 = NULL ;
9193 PyArrayObject *tmp3 = NULL ;
9194 int val6 ;
9195 int ecode6 = 0 ;
9196 PyArrayObject *tmp7 = NULL ;
9197 int val9 ;
9198 int ecode9 = 0 ;
9199 PyArrayObject *tmp10 = NULL ;
9200 PyArrayObject *tmp12 = NULL ;
9201 PyObject *swig_obj[8] ;
9202
9203 if (!SWIG_Python_UnpackTuple(args, "plsurf3dl", 8, 8, swig_obj)) SWIG_fail;
9204 {
9205 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9206 if ( tmp1 == NULL )
9207 return NULL;
9208 Xlen = PyArray_DIMS( tmp1 )[0];
9209 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9210 }
9211 {
9212 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9213 if ( tmp2 == NULL )
9214 return NULL;
9215 Ylen = PyArray_DIMS( tmp2 )[0];
9216 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9217 }
9218 {
9219 int i, size;
9220 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9221 if ( tmp3 == NULL )
9222 return NULL;
9223 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9224 {
9225 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9226 return NULL;
9227 }
9228 arg4 = PyArray_DIMS( tmp3 )[0];
9229 arg5 = PyArray_DIMS( tmp3 )[1];
9230 size = arg5;
9231 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9232 for ( i = 0; i < arg4; i++ )
9233 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9234 }
9235 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9236 if (!SWIG_IsOK(ecode6)) {
9237 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9238 }
9239 arg6 = (PLINT)(val6);
9240 {
9241 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9242 if ( tmp7 == NULL )
9243 return NULL;
9244 arg8 = PyArray_DIMS( tmp7 )[0];
9245 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9246 }
9247 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9248 if (!SWIG_IsOK(ecode9)) {
9249 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9250 }
9251 arg9 = (PLINT)(val9);
9252 {
9253 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9254 if ( tmp10 == NULL )
9255 return NULL;
9256 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9257 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9258 }
9259 {
9260 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9261 if ( tmp12 == NULL )
9262 return NULL;
9263 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9264 {
9265 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9266 return NULL;
9267 }
9268 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9269 }
9270 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);
9271 resultobj = SWIG_Py_Void();
9272 {
9273 Py_CLEAR( tmp1 );
9274 }
9275 {
9276 Py_CLEAR( tmp2 );
9277 }
9278 {
9279 Py_CLEAR( tmp3 );
9280 free( arg3 );
9281 }
9282 {
9283 Py_CLEAR( tmp7 );
9284 }
9285 {
9286 Py_CLEAR( tmp10 );
9287 }
9288 {
9289 Py_CLEAR( tmp12 );
9290 }
9291 return resultobj;
9292fail:
9293 {
9294 Py_CLEAR( tmp1 );
9295 }
9296 {
9297 Py_CLEAR( tmp2 );
9298 }
9299 {
9300 Py_CLEAR( tmp3 );
9301 free( arg3 );
9302 }
9303 {
9304 Py_CLEAR( tmp7 );
9305 }
9306 {
9307 Py_CLEAR( tmp10 );
9308 }
9309 {
9310 Py_CLEAR( tmp12 );
9311 }
9312 return NULL;
9313}
9314
9315
9316SWIGINTERN PyObject *_wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9317 PyObject *resultobj = 0;
9318 int *arg1 = (int *) 0 ;
9319 char **arg2 = (char **) 0 ;
9320 PLINT arg3 ;
9321 int tmp1 ;
9322 int val3 ;
9323 int ecode3 = 0 ;
9324 PyObject *swig_obj[2] ;
9325 PLINT result;
9326
9327 if (!SWIG_Python_UnpackTuple(args, "plparseopts", 2, 2, swig_obj)) SWIG_fail;
9328 {
9329 int i;
9330 PyObject *unicode_string;
9331
9332 if ( !PyList_Check( swig_obj[0] ) )
9333 {
9334 PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9335 return NULL;
9336 }
9337 tmp1 = PyList_Size( swig_obj[0] );
9338 arg1 = &tmp1;
9339 arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9340 for ( i = 0; i < tmp1; i++ )
9341 {
9342 PyObject *s = PyList_GetItem( swig_obj[0], i );
9343 if ( PyString_Check( s ) )
9344 {
9345 arg2[i] = PyString_AsString( s );
9346 }
9347 else if ( PyUnicode_Check( s ) )
9348 {
9349 // unicode_string is never freed? memory leak here?
9350 unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9351 arg2[i] = PyBytes_AS_STRING( unicode_string );
9352 }
9353 else
9354 {
9355 free( arg2 );
9356 PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9357 return NULL;
9358 }
9359 }
9360 arg2[i] = 0;
9361 }
9362 ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
9363 if (!SWIG_IsOK(ecode3)) {
9364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9365 }
9366 arg3 = (PLINT)(val3);
9367 result = (PLINT)plparseopts(arg1,arg2,arg3);
9368 resultobj = SWIG_From_int((int)(result));
9369 {
9370 if ( arg2 )
9371 free( arg2 );
9372 }
9373 return resultobj;
9374fail:
9375 {
9376 if ( arg2 )
9377 free( arg2 );
9378 }
9379 return NULL;
9380}
9381
9382
9383SWIGINTERN PyObject *_wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9384 PyObject *resultobj = 0;
9385 PLINT arg1 ;
9386 PLINT *arg2 = (PLINT *) 0 ;
9387 PLINT *arg3 = (PLINT *) 0 ;
9388 PyArrayObject *tmp1 = NULL ;
9389 PyArrayObject *tmp3 = NULL ;
9390 PyObject *swig_obj[2] ;
9391
9392 if (!SWIG_Python_UnpackTuple(args, "plpat", 2, 2, swig_obj)) SWIG_fail;
9393 {
9394 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
9395 if ( tmp1 == NULL )
9396 return NULL;
9397 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9398 arg2 = (PLINT *) PyArray_DATA( tmp1 );
9399 }
9400 {
9401 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
9402 if ( tmp3 == NULL )
9403 return NULL;
9404 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9405 {
9406 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9407 return NULL;
9408 }
9409 arg3 = (PLINT *) PyArray_DATA( tmp3 );
9410 }
9411 plpat(arg1,(int const *)arg2,(int const *)arg3);
9412 resultobj = SWIG_Py_Void();
9413 {
9414 Py_CLEAR( tmp1 );
9415 }
9416 {
9417 Py_CLEAR( tmp3 );
9418 }
9419 return resultobj;
9420fail:
9421 {
9422 Py_CLEAR( tmp1 );
9423 }
9424 {
9425 Py_CLEAR( tmp3 );
9426 }
9427 return NULL;
9428}
9429
9430
9431SWIGINTERN PyObject *_wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9432 PyObject *resultobj = 0;
9433 PLINT arg1 ;
9434 PLFLT arg2 ;
9435 PLFLT arg3 ;
9436 PLFLT arg4 ;
9437 PLFLT arg5 ;
9438 int val1 ;
9439 int ecode1 = 0 ;
9440 double val2 ;
9441 int ecode2 = 0 ;
9442 double val3 ;
9443 int ecode3 = 0 ;
9444 double val4 ;
9445 int ecode4 = 0 ;
9446 double val5 ;
9447 int ecode5 = 0 ;
9448 PyObject *swig_obj[5] ;
9449
9450 if (!SWIG_Python_UnpackTuple(args, "plpath", 5, 5, swig_obj)) SWIG_fail;
9451 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9452 if (!SWIG_IsOK(ecode1)) {
9453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
9454 }
9455 arg1 = (PLINT)(val1);
9456 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9457 if (!SWIG_IsOK(ecode2)) {
9458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
9459 }
9460 arg2 = (PLFLT)(val2);
9461 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9462 if (!SWIG_IsOK(ecode3)) {
9463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
9464 }
9465 arg3 = (PLFLT)(val3);
9466 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9467 if (!SWIG_IsOK(ecode4)) {
9468 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
9469 }
9470 arg4 = (PLFLT)(val4);
9471 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9472 if (!SWIG_IsOK(ecode5)) {
9473 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
9474 }
9475 arg5 = (PLFLT)(val5);
9476 plpath(arg1,arg2,arg3,arg4,arg5);
9477 resultobj = SWIG_Py_Void();
9478 return resultobj;
9479fail:
9480 return NULL;
9481}
9482
9483
9484SWIGINTERN PyObject *_wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9485 PyObject *resultobj = 0;
9486 PLINT arg1 ;
9487 PLFLT *arg2 = (PLFLT *) 0 ;
9488 PLFLT *arg3 = (PLFLT *) 0 ;
9489 PLINT arg4 ;
9490 PyArrayObject *tmp1 = NULL ;
9491 PyArrayObject *tmp3 = NULL ;
9492 int val4 ;
9493 int ecode4 = 0 ;
9494 PyObject *swig_obj[3] ;
9495
9496 if (!SWIG_Python_UnpackTuple(args, "plpoin", 3, 3, swig_obj)) SWIG_fail;
9497 {
9498 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9499 if ( tmp1 == NULL )
9500 return NULL;
9501 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9502 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9503 }
9504 {
9505 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9506 if ( tmp3 == NULL )
9507 return NULL;
9508 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9509 {
9510 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9511 return NULL;
9512 }
9513 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9514 }
9515 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
9516 if (!SWIG_IsOK(ecode4)) {
9517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
9518 }
9519 arg4 = (PLINT)(val4);
9520 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
9521 resultobj = SWIG_Py_Void();
9522 {
9523 Py_CLEAR( tmp1 );
9524 }
9525 {
9526 Py_CLEAR( tmp3 );
9527 }
9528 return resultobj;
9529fail:
9530 {
9531 Py_CLEAR( tmp1 );
9532 }
9533 {
9534 Py_CLEAR( tmp3 );
9535 }
9536 return NULL;
9537}
9538
9539
9540SWIGINTERN PyObject *_wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9541 PyObject *resultobj = 0;
9542 PLINT arg1 ;
9543 PLFLT *arg2 = (PLFLT *) 0 ;
9544 PLFLT *arg3 = (PLFLT *) 0 ;
9545 PLFLT *arg4 = (PLFLT *) 0 ;
9546 PLINT arg5 ;
9547 PyArrayObject *tmp1 = NULL ;
9548 PyArrayObject *tmp3 = NULL ;
9549 PyArrayObject *tmp4 = NULL ;
9550 int val5 ;
9551 int ecode5 = 0 ;
9552 PyObject *swig_obj[4] ;
9553
9554 if (!SWIG_Python_UnpackTuple(args, "plpoin3", 4, 4, swig_obj)) SWIG_fail;
9555 {
9556 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9557 if ( tmp1 == NULL )
9558 return NULL;
9559 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9560 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9561 }
9562 {
9563 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9564 if ( tmp3 == NULL )
9565 return NULL;
9566 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9567 {
9568 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9569 return NULL;
9570 }
9571 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9572 }
9573 {
9574 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9575 if ( tmp4 == NULL )
9576 return NULL;
9577 if ( PyArray_DIMS( tmp4 )[0] != Alen )
9578 {
9579 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9580 return NULL;
9581 }
9582 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9583 }
9584 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
9585 if (!SWIG_IsOK(ecode5)) {
9586 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
9587 }
9588 arg5 = (PLINT)(val5);
9589 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
9590 resultobj = SWIG_Py_Void();
9591 {
9592 Py_CLEAR( tmp1 );
9593 }
9594 {
9595 Py_CLEAR( tmp3 );
9596 }
9597 {
9598 Py_CLEAR( tmp4 );
9599 }
9600 return resultobj;
9601fail:
9602 {
9603 Py_CLEAR( tmp1 );
9604 }
9605 {
9606 Py_CLEAR( tmp3 );
9607 }
9608 {
9609 Py_CLEAR( tmp4 );
9610 }
9611 return NULL;
9612}
9613
9614
9615SWIGINTERN PyObject *_wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9616 PyObject *resultobj = 0;
9617 PLINT arg1 ;
9618 PLFLT *arg2 = (PLFLT *) 0 ;
9619 PLFLT *arg3 = (PLFLT *) 0 ;
9620 PLFLT *arg4 = (PLFLT *) 0 ;
9621 PLBOOL *arg5 = (PLBOOL *) 0 ;
9622 PLBOOL arg6 ;
9623 PyArrayObject *tmp1 = NULL ;
9624 PyArrayObject *tmp3 = NULL ;
9625 PyArrayObject *tmp4 = NULL ;
9626 PyArrayObject *tmp5 = NULL ;
9627 int val6 ;
9628 int ecode6 = 0 ;
9629 PyObject *swig_obj[5] ;
9630
9631 if (!SWIG_Python_UnpackTuple(args, "plpoly3", 5, 5, swig_obj)) SWIG_fail;
9632 {
9633 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9634 if ( tmp1 == NULL )
9635 return NULL;
9636 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9637 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9638 }
9639 {
9640 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9641 if ( tmp3 == NULL )
9642 return NULL;
9643 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9644 {
9645 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9646 return NULL;
9647 }
9648 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9649 }
9650 {
9651 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9652 if ( tmp4 == NULL )
9653 return NULL;
9654 if ( PyArray_DIMS( tmp4 )[0] != Alen )
9655 {
9656 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9657 return NULL;
9658 }
9659 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9660 }
9661 {
9662 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[3], NPY_PLINT, 1, 1 );
9663 if ( tmp5 == NULL )
9664 return NULL;
9665 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
9666 {
9667 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
9668 return NULL;
9669 }
9670 arg5 = (PLINT *) PyArray_DATA( tmp5 );
9671 }
9672 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
9673 if (!SWIG_IsOK(ecode6)) {
9674 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
9675 }
9676 arg6 = (PLBOOL)(val6);
9677 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
9678 resultobj = SWIG_Py_Void();
9679 {
9680 Py_CLEAR( tmp1 );
9681 }
9682 {
9683 Py_CLEAR( tmp3 );
9684 }
9685 {
9686 Py_CLEAR( tmp4 );
9687 }
9688 {
9689 Py_CLEAR( tmp5 );
9690 }
9691 return resultobj;
9692fail:
9693 {
9694 Py_CLEAR( tmp1 );
9695 }
9696 {
9697 Py_CLEAR( tmp3 );
9698 }
9699 {
9700 Py_CLEAR( tmp4 );
9701 }
9702 {
9703 Py_CLEAR( tmp5 );
9704 }
9705 return NULL;
9706}
9707
9708
9709SWIGINTERN PyObject *_wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9710 PyObject *resultobj = 0;
9711 PLINT arg1 ;
9712 PLINT arg2 ;
9713 int val1 ;
9714 int ecode1 = 0 ;
9715 int val2 ;
9716 int ecode2 = 0 ;
9717 PyObject *swig_obj[2] ;
9718
9719 if (!SWIG_Python_UnpackTuple(args, "plprec", 2, 2, swig_obj)) SWIG_fail;
9720 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9721 if (!SWIG_IsOK(ecode1)) {
9722 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
9723 }
9724 arg1 = (PLINT)(val1);
9725 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
9726 if (!SWIG_IsOK(ecode2)) {
9727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
9728 }
9729 arg2 = (PLINT)(val2);
9730 plprec(arg1,arg2);
9731 resultobj = SWIG_Py_Void();
9732 return resultobj;
9733fail:
9734 return NULL;
9735}
9736
9737
9738SWIGINTERN PyObject *_wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9739 PyObject *resultobj = 0;
9740 PLINT arg1 ;
9741 int val1 ;
9742 int ecode1 = 0 ;
9743 PyObject *swig_obj[1] ;
9744
9745 if (!args) SWIG_fail;
9746 swig_obj[0] = args;
9747 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9748 if (!SWIG_IsOK(ecode1)) {
9749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
9750 }
9751 arg1 = (PLINT)(val1);
9752 plpsty(arg1);
9753 resultobj = SWIG_Py_Void();
9754 return resultobj;
9755fail:
9756 return NULL;
9757}
9758
9759
9760SWIGINTERN PyObject *_wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9761 PyObject *resultobj = 0;
9762 PLFLT arg1 ;
9763 PLFLT arg2 ;
9764 PLFLT arg3 ;
9765 PLFLT arg4 ;
9766 PLFLT arg5 ;
9767 char *arg6 = (char *) 0 ;
9768 double val1 ;
9769 int ecode1 = 0 ;
9770 double val2 ;
9771 int ecode2 = 0 ;
9772 double val3 ;
9773 int ecode3 = 0 ;
9774 double val4 ;
9775 int ecode4 = 0 ;
9776 double val5 ;
9777 int ecode5 = 0 ;
9778 int res6 ;
9779 char *buf6 = 0 ;
9780 int alloc6 = 0 ;
9781 PyObject *swig_obj[6] ;
9782
9783 if (!SWIG_Python_UnpackTuple(args, "plptex", 6, 6, swig_obj)) SWIG_fail;
9784 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9785 if (!SWIG_IsOK(ecode1)) {
9786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
9787 }
9788 arg1 = (PLFLT)(val1);
9789 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9790 if (!SWIG_IsOK(ecode2)) {
9791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
9792 }
9793 arg2 = (PLFLT)(val2);
9794 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9795 if (!SWIG_IsOK(ecode3)) {
9796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
9797 }
9798 arg3 = (PLFLT)(val3);
9799 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9800 if (!SWIG_IsOK(ecode4)) {
9801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
9802 }
9803 arg4 = (PLFLT)(val4);
9804 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9805 if (!SWIG_IsOK(ecode5)) {
9806 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
9807 }
9808 arg5 = (PLFLT)(val5);
9809 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
9810 if (!SWIG_IsOK(res6)) {
9811 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
9812 }
9813 arg6 = (char *)(buf6);
9814 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
9815 resultobj = SWIG_Py_Void();
9816 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
9817 return resultobj;
9818fail:
9819 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
9820 return NULL;
9821}
9822
9823
9824SWIGINTERN PyObject *_wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9825 PyObject *resultobj = 0;
9826 PLFLT arg1 ;
9827 PLFLT arg2 ;
9828 PLFLT arg3 ;
9829 PLFLT arg4 ;
9830 PLFLT arg5 ;
9831 PLFLT arg6 ;
9832 PLFLT arg7 ;
9833 PLFLT arg8 ;
9834 PLFLT arg9 ;
9835 PLFLT arg10 ;
9836 char *arg11 = (char *) 0 ;
9837 double val1 ;
9838 int ecode1 = 0 ;
9839 double val2 ;
9840 int ecode2 = 0 ;
9841 double val3 ;
9842 int ecode3 = 0 ;
9843 double val4 ;
9844 int ecode4 = 0 ;
9845 double val5 ;
9846 int ecode5 = 0 ;
9847 double val6 ;
9848 int ecode6 = 0 ;
9849 double val7 ;
9850 int ecode7 = 0 ;
9851 double val8 ;
9852 int ecode8 = 0 ;
9853 double val9 ;
9854 int ecode9 = 0 ;
9855 double val10 ;
9856 int ecode10 = 0 ;
9857 int res11 ;
9858 char *buf11 = 0 ;
9859 int alloc11 = 0 ;
9860 PyObject *swig_obj[11] ;
9861
9862 if (!SWIG_Python_UnpackTuple(args, "plptex3", 11, 11, swig_obj)) SWIG_fail;
9863 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9864 if (!SWIG_IsOK(ecode1)) {
9865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
9866 }
9867 arg1 = (PLFLT)(val1);
9868 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9869 if (!SWIG_IsOK(ecode2)) {
9870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
9871 }
9872 arg2 = (PLFLT)(val2);
9873 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9874 if (!SWIG_IsOK(ecode3)) {
9875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
9876 }
9877 arg3 = (PLFLT)(val3);
9878 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9879 if (!SWIG_IsOK(ecode4)) {
9880 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
9881 }
9882 arg4 = (PLFLT)(val4);
9883 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9884 if (!SWIG_IsOK(ecode5)) {
9885 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
9886 }
9887 arg5 = (PLFLT)(val5);
9888 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
9889 if (!SWIG_IsOK(ecode6)) {
9890 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
9891 }
9892 arg6 = (PLFLT)(val6);
9893 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
9894 if (!SWIG_IsOK(ecode7)) {
9895 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
9896 }
9897 arg7 = (PLFLT)(val7);
9898 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
9899 if (!SWIG_IsOK(ecode8)) {
9900 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
9901 }
9902 arg8 = (PLFLT)(val8);
9903 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
9904 if (!SWIG_IsOK(ecode9)) {
9905 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
9906 }
9907 arg9 = (PLFLT)(val9);
9908 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
9909 if (!SWIG_IsOK(ecode10)) {
9910 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
9911 }
9912 arg10 = (PLFLT)(val10);
9913 res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
9914 if (!SWIG_IsOK(res11)) {
9915 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
9916 }
9917 arg11 = (char *)(buf11);
9918 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
9919 resultobj = SWIG_Py_Void();
9920 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
9921 return resultobj;
9922fail:
9923 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
9924 return NULL;
9925}
9926
9927
9928SWIGINTERN PyObject *_wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9929 PyObject *resultobj = 0;
9930 PLFLT result;
9931
9932 if (!SWIG_Python_UnpackTuple(args, "plrandd", 0, 0, 0)) SWIG_fail;
9933 result = (PLFLT)plrandd();
9934 resultobj = SWIG_From_double((double)(result));
9935 return resultobj;
9936fail:
9937 return NULL;
9938}
9939
9940
9941SWIGINTERN PyObject *_wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9942 PyObject *resultobj = 0;
9943
9944 if (!SWIG_Python_UnpackTuple(args, "plreplot", 0, 0, 0)) SWIG_fail;
9945 plreplot();
9946 resultobj = SWIG_Py_Void();
9947 return resultobj;
9948fail:
9949 return NULL;
9950}
9951
9952
9953SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9954 PyObject *resultobj = 0;
9955 PLFLT arg1 ;
9956 PLFLT arg2 ;
9957 PLFLT arg3 ;
9958 PLFLT *arg4 = (PLFLT *) 0 ;
9959 PLFLT *arg5 = (PLFLT *) 0 ;
9960 PLFLT *arg6 = (PLFLT *) 0 ;
9961 double val1 ;
9962 int ecode1 = 0 ;
9963 double val2 ;
9964 int ecode2 = 0 ;
9965 double val3 ;
9966 int ecode3 = 0 ;
9967 PLFLT temp4 ;
9968 int res4 = SWIG_TMPOBJ ;
9969 PLFLT temp5 ;
9970 int res5 = SWIG_TMPOBJ ;
9971 PLFLT temp6 ;
9972 int res6 = SWIG_TMPOBJ ;
9973 PyObject *swig_obj[3] ;
9974
9975 arg4 = &temp4;
9976 arg5 = &temp5;
9977 arg6 = &temp6;
9978 if (!SWIG_Python_UnpackTuple(args, "plrgbhls", 3, 3, swig_obj)) SWIG_fail;
9979 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
9980 if (!SWIG_IsOK(ecode1)) {
9981 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
9982 }
9983 arg1 = (PLFLT)(val1);
9984 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9985 if (!SWIG_IsOK(ecode2)) {
9986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
9987 }
9988 arg2 = (PLFLT)(val2);
9989 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9990 if (!SWIG_IsOK(ecode3)) {
9991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
9992 }
9993 arg3 = (PLFLT)(val3);
9994 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
9995 resultobj = SWIG_Py_Void();
9996 if (SWIG_IsTmpObj(res4)) {
9997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
9998 } else {
9999 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10001 }
10002 if (SWIG_IsTmpObj(res5)) {
10003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10004 } else {
10005 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10007 }
10008 if (SWIG_IsTmpObj(res6)) {
10009 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10010 } else {
10011 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10013 }
10014 return resultobj;
10015fail:
10016 return NULL;
10017}
10018
10019
10020SWIGINTERN PyObject *_wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10021 PyObject *resultobj = 0;
10022 PLFLT arg1 ;
10023 PLFLT arg2 ;
10024 double val1 ;
10025 int ecode1 = 0 ;
10026 double val2 ;
10027 int ecode2 = 0 ;
10028 PyObject *swig_obj[2] ;
10029
10030 if (!SWIG_Python_UnpackTuple(args, "plschr", 2, 2, swig_obj)) SWIG_fail;
10031 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10032 if (!SWIG_IsOK(ecode1)) {
10033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10034 }
10035 arg1 = (PLFLT)(val1);
10036 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10037 if (!SWIG_IsOK(ecode2)) {
10038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10039 }
10040 arg2 = (PLFLT)(val2);
10041 plschr(arg1,arg2);
10042 resultobj = SWIG_Py_Void();
10043 return resultobj;
10044fail:
10045 return NULL;
10046}
10047
10048
10049SWIGINTERN PyObject *_wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10050 PyObject *resultobj = 0;
10051 PLINT *arg1 = (PLINT *) 0 ;
10052 PLINT *arg2 = (PLINT *) 0 ;
10053 PLINT *arg3 = (PLINT *) 0 ;
10054 PLINT arg4 ;
10055 PyArrayObject *tmp1 = NULL ;
10056 PyArrayObject *tmp2 = NULL ;
10057 PyArrayObject *tmp3 = NULL ;
10058 PyObject *swig_obj[3] ;
10059
10060 if (!SWIG_Python_UnpackTuple(args, "plscmap0", 3, 3, swig_obj)) SWIG_fail;
10061 {
10062 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10063 if ( tmp1 == NULL )
10064 return NULL;
10065 Alen = PyArray_DIMS( tmp1 )[0];
10066 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10067 }
10068 {
10069 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10070 if ( tmp2 == NULL )
10071 return NULL;
10072 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10073 {
10074 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10075 return NULL;
10076 }
10077 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10078 }
10079 {
10080 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10081 if ( tmp3 == NULL )
10082 return NULL;
10083 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10084 {
10085 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10086 return NULL;
10087 }
10088 arg4 = PyArray_DIMS( tmp3 )[0];
10089 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10090 }
10091 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10092 resultobj = SWIG_Py_Void();
10093 {
10094 Py_CLEAR( tmp1 );
10095 }
10096 {
10097 Py_CLEAR( tmp2 );
10098 }
10099 {
10100 Py_CLEAR( tmp3 );
10101 }
10102 return resultobj;
10103fail:
10104 {
10105 Py_CLEAR( tmp1 );
10106 }
10107 {
10108 Py_CLEAR( tmp2 );
10109 }
10110 {
10111 Py_CLEAR( tmp3 );
10112 }
10113 return NULL;
10114}
10115
10116
10117SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10118 PyObject *resultobj = 0;
10119 PLINT *arg1 = (PLINT *) 0 ;
10120 PLINT *arg2 = (PLINT *) 0 ;
10121 PLINT *arg3 = (PLINT *) 0 ;
10122 PLFLT *arg4 = (PLFLT *) 0 ;
10123 PLINT arg5 ;
10124 PyArrayObject *tmp1 = NULL ;
10125 PyArrayObject *tmp2 = NULL ;
10126 PyArrayObject *tmp3 = NULL ;
10127 PyArrayObject *tmp4 = NULL ;
10128 PyObject *swig_obj[4] ;
10129
10130 if (!SWIG_Python_UnpackTuple(args, "plscmap0a", 4, 4, swig_obj)) SWIG_fail;
10131 {
10132 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10133 if ( tmp1 == NULL )
10134 return NULL;
10135 Alen = PyArray_DIMS( tmp1 )[0];
10136 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10137 }
10138 {
10139 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10140 if ( tmp2 == NULL )
10141 return NULL;
10142 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10143 {
10144 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10145 return NULL;
10146 }
10147 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10148 }
10149 {
10150 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10151 if ( tmp3 == NULL )
10152 return NULL;
10153 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10154 {
10155 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10156 return NULL;
10157 }
10158 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10159 }
10160 {
10161 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10162 if ( tmp4 == NULL )
10163 return NULL;
10164 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10165 {
10166 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10167 return NULL;
10168 }
10169 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10170 arg5 = PyArray_DIMS( tmp4 )[0];
10171 }
10172 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10173 resultobj = SWIG_Py_Void();
10174 {
10175 Py_CLEAR( tmp1 );
10176 }
10177 {
10178 Py_CLEAR( tmp2 );
10179 }
10180 {
10181 Py_CLEAR( tmp3 );
10182 }
10183 {
10184 Py_CLEAR( tmp4 );
10185 }
10186 return resultobj;
10187fail:
10188 {
10189 Py_CLEAR( tmp1 );
10190 }
10191 {
10192 Py_CLEAR( tmp2 );
10193 }
10194 {
10195 Py_CLEAR( tmp3 );
10196 }
10197 {
10198 Py_CLEAR( tmp4 );
10199 }
10200 return NULL;
10201}
10202
10203
10204SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10205 PyObject *resultobj = 0;
10206 PLINT arg1 ;
10207 int val1 ;
10208 int ecode1 = 0 ;
10209 PyObject *swig_obj[1] ;
10210
10211 if (!args) SWIG_fail;
10212 swig_obj[0] = args;
10213 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10214 if (!SWIG_IsOK(ecode1)) {
10215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10216 }
10217 arg1 = (PLINT)(val1);
10218 plscmap0n(arg1);
10219 resultobj = SWIG_Py_Void();
10220 return resultobj;
10221fail:
10222 return NULL;
10223}
10224
10225
10226SWIGINTERN PyObject *_wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10227 PyObject *resultobj = 0;
10228 PLINT *arg1 = (PLINT *) 0 ;
10229 PLINT *arg2 = (PLINT *) 0 ;
10230 PLINT *arg3 = (PLINT *) 0 ;
10231 PLINT arg4 ;
10232 PyArrayObject *tmp1 = NULL ;
10233 PyArrayObject *tmp2 = NULL ;
10234 PyArrayObject *tmp3 = NULL ;
10235 PyObject *swig_obj[3] ;
10236
10237 if (!SWIG_Python_UnpackTuple(args, "plscmap1", 3, 3, swig_obj)) SWIG_fail;
10238 {
10239 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10240 if ( tmp1 == NULL )
10241 return NULL;
10242 Alen = PyArray_DIMS( tmp1 )[0];
10243 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10244 }
10245 {
10246 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10247 if ( tmp2 == NULL )
10248 return NULL;
10249 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10250 {
10251 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10252 return NULL;
10253 }
10254 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10255 }
10256 {
10257 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10258 if ( tmp3 == NULL )
10259 return NULL;
10260 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10261 {
10262 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10263 return NULL;
10264 }
10265 arg4 = PyArray_DIMS( tmp3 )[0];
10266 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10267 }
10268 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10269 resultobj = SWIG_Py_Void();
10270 {
10271 Py_CLEAR( tmp1 );
10272 }
10273 {
10274 Py_CLEAR( tmp2 );
10275 }
10276 {
10277 Py_CLEAR( tmp3 );
10278 }
10279 return resultobj;
10280fail:
10281 {
10282 Py_CLEAR( tmp1 );
10283 }
10284 {
10285 Py_CLEAR( tmp2 );
10286 }
10287 {
10288 Py_CLEAR( tmp3 );
10289 }
10290 return NULL;
10291}
10292
10293
10294SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10295 PyObject *resultobj = 0;
10296 PLINT *arg1 = (PLINT *) 0 ;
10297 PLINT *arg2 = (PLINT *) 0 ;
10298 PLINT *arg3 = (PLINT *) 0 ;
10299 PLFLT *arg4 = (PLFLT *) 0 ;
10300 PLINT arg5 ;
10301 PyArrayObject *tmp1 = NULL ;
10302 PyArrayObject *tmp2 = NULL ;
10303 PyArrayObject *tmp3 = NULL ;
10304 PyArrayObject *tmp4 = NULL ;
10305 PyObject *swig_obj[4] ;
10306
10307 if (!SWIG_Python_UnpackTuple(args, "plscmap1a", 4, 4, swig_obj)) SWIG_fail;
10308 {
10309 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10310 if ( tmp1 == NULL )
10311 return NULL;
10312 Alen = PyArray_DIMS( tmp1 )[0];
10313 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10314 }
10315 {
10316 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10317 if ( tmp2 == NULL )
10318 return NULL;
10319 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10320 {
10321 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10322 return NULL;
10323 }
10324 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10325 }
10326 {
10327 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10328 if ( tmp3 == NULL )
10329 return NULL;
10330 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10331 {
10332 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10333 return NULL;
10334 }
10335 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10336 }
10337 {
10338 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10339 if ( tmp4 == NULL )
10340 return NULL;
10341 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10342 {
10343 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10344 return NULL;
10345 }
10346 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10347 arg5 = PyArray_DIMS( tmp4 )[0];
10348 }
10349 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10350 resultobj = SWIG_Py_Void();
10351 {
10352 Py_CLEAR( tmp1 );
10353 }
10354 {
10355 Py_CLEAR( tmp2 );
10356 }
10357 {
10358 Py_CLEAR( tmp3 );
10359 }
10360 {
10361 Py_CLEAR( tmp4 );
10362 }
10363 return resultobj;
10364fail:
10365 {
10366 Py_CLEAR( tmp1 );
10367 }
10368 {
10369 Py_CLEAR( tmp2 );
10370 }
10371 {
10372 Py_CLEAR( tmp3 );
10373 }
10374 {
10375 Py_CLEAR( tmp4 );
10376 }
10377 return NULL;
10378}
10379
10380
10381SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10382 PyObject *resultobj = 0;
10383 PLBOOL arg1 ;
10384 PLINT arg2 ;
10385 PLFLT *arg3 = (PLFLT *) 0 ;
10386 PLFLT *arg4 = (PLFLT *) 0 ;
10387 PLFLT *arg5 = (PLFLT *) 0 ;
10388 PLFLT *arg6 = (PLFLT *) 0 ;
10389 PLBOOL *arg7 = (PLBOOL *) 0 ;
10390 int val1 ;
10391 int ecode1 = 0 ;
10392 PyArrayObject *tmp2 = NULL ;
10393 PyArrayObject *tmp4 = NULL ;
10394 PyArrayObject *tmp5 = NULL ;
10395 PyArrayObject *tmp6 = NULL ;
10396 PyArrayObject *tmp7 = NULL ;
10397 PyObject *swig_obj[6] ;
10398
10399 if (!SWIG_Python_UnpackTuple(args, "plscmap1l", 6, 6, swig_obj)) SWIG_fail;
10400 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10401 if (!SWIG_IsOK(ecode1)) {
10402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10403 }
10404 arg1 = (PLBOOL)(val1);
10405 {
10406 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10407 if ( tmp2 == NULL )
10408 return NULL;
10409 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10410 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10411 }
10412 {
10413 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10414 if ( tmp4 == NULL )
10415 return NULL;
10416 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10417 {
10418 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10419 return NULL;
10420 }
10421 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10422 }
10423 {
10424 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10425 if ( tmp5 == NULL )
10426 return NULL;
10427 if ( PyArray_DIMS( tmp5 )[0] != Alen )
10428 {
10429 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10430 return NULL;
10431 }
10432 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10433 }
10434 {
10435 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
10436 if ( tmp6 == NULL )
10437 return NULL;
10438 if ( PyArray_DIMS( tmp6 )[0] != Alen )
10439 {
10440 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10441 return NULL;
10442 }
10443 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10444 }
10445 {
10446 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[5], NPY_PLINT, 1, 1 );
10447 if ( tmp7 == NULL )
10448 return NULL;
10449 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10450 {
10451 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10452 return NULL;
10453 }
10454 arg7 = (PLINT *) PyArray_DATA( tmp7 );
10455 }
10456 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10457 resultobj = SWIG_Py_Void();
10458 {
10459 Py_CLEAR( tmp2 );
10460 }
10461 {
10462 Py_CLEAR( tmp4 );
10463 }
10464 {
10465 Py_CLEAR( tmp5 );
10466 }
10467 {
10468 Py_CLEAR( tmp6 );
10469 }
10470 {
10471 Py_CLEAR( tmp7 );
10472 }
10473 return resultobj;
10474fail:
10475 {
10476 Py_CLEAR( tmp2 );
10477 }
10478 {
10479 Py_CLEAR( tmp4 );
10480 }
10481 {
10482 Py_CLEAR( tmp5 );
10483 }
10484 {
10485 Py_CLEAR( tmp6 );
10486 }
10487 {
10488 Py_CLEAR( tmp7 );
10489 }
10490 return NULL;
10491}
10492
10493
10494SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10495 PyObject *resultobj = 0;
10496 PLBOOL arg1 ;
10497 PLINT arg2 ;
10498 PLFLT *arg3 = (PLFLT *) 0 ;
10499 PLFLT *arg4 = (PLFLT *) 0 ;
10500 PLFLT *arg5 = (PLFLT *) 0 ;
10501 PLFLT *arg6 = (PLFLT *) 0 ;
10502 PLFLT *arg7 = (PLFLT *) 0 ;
10503 PLBOOL *arg8 = (PLBOOL *) 0 ;
10504 int val1 ;
10505 int ecode1 = 0 ;
10506 PyArrayObject *tmp2 = NULL ;
10507 PyArrayObject *tmp4 = NULL ;
10508 PyArrayObject *tmp5 = NULL ;
10509 PyArrayObject *tmp6 = NULL ;
10510 PyArrayObject *tmp7 = NULL ;
10511 PyArrayObject *tmp8 = NULL ;
10512 PyObject *swig_obj[7] ;
10513
10514 if (!SWIG_Python_UnpackTuple(args, "plscmap1la", 7, 7, swig_obj)) SWIG_fail;
10515 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10516 if (!SWIG_IsOK(ecode1)) {
10517 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10518 }
10519 arg1 = (PLBOOL)(val1);
10520 {
10521 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10522 if ( tmp2 == NULL )
10523 return NULL;
10524 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10525 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10526 }
10527 {
10528 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10529 if ( tmp4 == NULL )
10530 return NULL;
10531 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10532 {
10533 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10534 return NULL;
10535 }
10536 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10537 }
10538 {
10539 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10540 if ( tmp5 == NULL )
10541 return NULL;
10542 if ( PyArray_DIMS( tmp5 )[0] != Alen )
10543 {
10544 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10545 return NULL;
10546 }
10547 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10548 }
10549 {
10550 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
10551 if ( tmp6 == NULL )
10552 return NULL;
10553 if ( PyArray_DIMS( tmp6 )[0] != Alen )
10554 {
10555 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10556 return NULL;
10557 }
10558 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10559 }
10560 {
10561 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
10562 if ( tmp7 == NULL )
10563 return NULL;
10564 if ( PyArray_DIMS( tmp7 )[0] != Alen )
10565 {
10566 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10567 return NULL;
10568 }
10569 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10570 }
10571 {
10572 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
10573 if ( tmp8 == NULL )
10574 return NULL;
10575 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10576 {
10577 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10578 return NULL;
10579 }
10580 arg8 = (PLINT *) PyArray_DATA( tmp8 );
10581 }
10582 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
10583 resultobj = SWIG_Py_Void();
10584 {
10585 Py_CLEAR( tmp2 );
10586 }
10587 {
10588 Py_CLEAR( tmp4 );
10589 }
10590 {
10591 Py_CLEAR( tmp5 );
10592 }
10593 {
10594 Py_CLEAR( tmp6 );
10595 }
10596 {
10597 Py_CLEAR( tmp7 );
10598 }
10599 {
10600 Py_CLEAR( tmp8 );
10601 }
10602 return resultobj;
10603fail:
10604 {
10605 Py_CLEAR( tmp2 );
10606 }
10607 {
10608 Py_CLEAR( tmp4 );
10609 }
10610 {
10611 Py_CLEAR( tmp5 );
10612 }
10613 {
10614 Py_CLEAR( tmp6 );
10615 }
10616 {
10617 Py_CLEAR( tmp7 );
10618 }
10619 {
10620 Py_CLEAR( tmp8 );
10621 }
10622 return NULL;
10623}
10624
10625
10626SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10627 PyObject *resultobj = 0;
10628 PLINT arg1 ;
10629 int val1 ;
10630 int ecode1 = 0 ;
10631 PyObject *swig_obj[1] ;
10632
10633 if (!args) SWIG_fail;
10634 swig_obj[0] = args;
10635 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10636 if (!SWIG_IsOK(ecode1)) {
10637 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
10638 }
10639 arg1 = (PLINT)(val1);
10640 plscmap1n(arg1);
10641 resultobj = SWIG_Py_Void();
10642 return resultobj;
10643fail:
10644 return NULL;
10645}
10646
10647
10648SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10649 PyObject *resultobj = 0;
10650 PLFLT arg1 ;
10651 PLFLT arg2 ;
10652 double val1 ;
10653 int ecode1 = 0 ;
10654 double val2 ;
10655 int ecode2 = 0 ;
10656 PyObject *swig_obj[2] ;
10657
10658 if (!SWIG_Python_UnpackTuple(args, "plscmap1_range", 2, 2, swig_obj)) SWIG_fail;
10659 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10660 if (!SWIG_IsOK(ecode1)) {
10661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
10662 }
10663 arg1 = (PLFLT)(val1);
10664 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10665 if (!SWIG_IsOK(ecode2)) {
10666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
10667 }
10668 arg2 = (PLFLT)(val2);
10669 plscmap1_range(arg1,arg2);
10670 resultobj = SWIG_Py_Void();
10671 return resultobj;
10672fail:
10673 return NULL;
10674}
10675
10676
10677SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10678 PyObject *resultobj = 0;
10679 PLFLT *arg1 = (PLFLT *) 0 ;
10680 PLFLT *arg2 = (PLFLT *) 0 ;
10681 PLFLT temp1 ;
10682 int res1 = SWIG_TMPOBJ ;
10683 PLFLT temp2 ;
10684 int res2 = SWIG_TMPOBJ ;
10685
10686 arg1 = &temp1;
10687 arg2 = &temp2;
10688 if (!SWIG_Python_UnpackTuple(args, "plgcmap1_range", 0, 0, 0)) SWIG_fail;
10689 plgcmap1_range(arg1,arg2);
10690 resultobj = SWIG_Py_Void();
10691 if (SWIG_IsTmpObj(res1)) {
10692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
10693 } else {
10694 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
10696 }
10697 if (SWIG_IsTmpObj(res2)) {
10698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
10699 } else {
10700 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
10702 }
10703 return resultobj;
10704fail:
10705 return NULL;
10706}
10707
10708
10709SWIGINTERN PyObject *_wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10710 PyObject *resultobj = 0;
10711 PLINT arg1 ;
10712 PLINT arg2 ;
10713 PLINT arg3 ;
10714 PLINT arg4 ;
10715 int val1 ;
10716 int ecode1 = 0 ;
10717 int val2 ;
10718 int ecode2 = 0 ;
10719 int val3 ;
10720 int ecode3 = 0 ;
10721 int val4 ;
10722 int ecode4 = 0 ;
10723 PyObject *swig_obj[4] ;
10724
10725 if (!SWIG_Python_UnpackTuple(args, "plscol0", 4, 4, swig_obj)) SWIG_fail;
10726 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10727 if (!SWIG_IsOK(ecode1)) {
10728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
10729 }
10730 arg1 = (PLINT)(val1);
10731 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10732 if (!SWIG_IsOK(ecode2)) {
10733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
10734 }
10735 arg2 = (PLINT)(val2);
10736 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10737 if (!SWIG_IsOK(ecode3)) {
10738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
10739 }
10740 arg3 = (PLINT)(val3);
10741 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
10742 if (!SWIG_IsOK(ecode4)) {
10743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
10744 }
10745 arg4 = (PLINT)(val4);
10746 plscol0(arg1,arg2,arg3,arg4);
10747 resultobj = SWIG_Py_Void();
10748 return resultobj;
10749fail:
10750 return NULL;
10751}
10752
10753
10754SWIGINTERN PyObject *_wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10755 PyObject *resultobj = 0;
10756 PLINT arg1 ;
10757 PLINT arg2 ;
10758 PLINT arg3 ;
10759 PLINT arg4 ;
10760 PLFLT arg5 ;
10761 int val1 ;
10762 int ecode1 = 0 ;
10763 int val2 ;
10764 int ecode2 = 0 ;
10765 int val3 ;
10766 int ecode3 = 0 ;
10767 int val4 ;
10768 int ecode4 = 0 ;
10769 double val5 ;
10770 int ecode5 = 0 ;
10771 PyObject *swig_obj[5] ;
10772
10773 if (!SWIG_Python_UnpackTuple(args, "plscol0a", 5, 5, swig_obj)) SWIG_fail;
10774 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10775 if (!SWIG_IsOK(ecode1)) {
10776 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
10777 }
10778 arg1 = (PLINT)(val1);
10779 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10780 if (!SWIG_IsOK(ecode2)) {
10781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
10782 }
10783 arg2 = (PLINT)(val2);
10784 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10785 if (!SWIG_IsOK(ecode3)) {
10786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
10787 }
10788 arg3 = (PLINT)(val3);
10789 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
10790 if (!SWIG_IsOK(ecode4)) {
10791 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
10792 }
10793 arg4 = (PLINT)(val4);
10794 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10795 if (!SWIG_IsOK(ecode5)) {
10796 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
10797 }
10798 arg5 = (PLFLT)(val5);
10799 plscol0a(arg1,arg2,arg3,arg4,arg5);
10800 resultobj = SWIG_Py_Void();
10801 return resultobj;
10802fail:
10803 return NULL;
10804}
10805
10806
10807SWIGINTERN PyObject *_wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10808 PyObject *resultobj = 0;
10809 PLINT arg1 ;
10810 PLINT arg2 ;
10811 PLINT arg3 ;
10812 int val1 ;
10813 int ecode1 = 0 ;
10814 int val2 ;
10815 int ecode2 = 0 ;
10816 int val3 ;
10817 int ecode3 = 0 ;
10818 PyObject *swig_obj[3] ;
10819
10820 if (!SWIG_Python_UnpackTuple(args, "plscolbg", 3, 3, swig_obj)) SWIG_fail;
10821 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10822 if (!SWIG_IsOK(ecode1)) {
10823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
10824 }
10825 arg1 = (PLINT)(val1);
10826 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10827 if (!SWIG_IsOK(ecode2)) {
10828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
10829 }
10830 arg2 = (PLINT)(val2);
10831 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10832 if (!SWIG_IsOK(ecode3)) {
10833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
10834 }
10835 arg3 = (PLINT)(val3);
10836 plscolbg(arg1,arg2,arg3);
10837 resultobj = SWIG_Py_Void();
10838 return resultobj;
10839fail:
10840 return NULL;
10841}
10842
10843
10844SWIGINTERN PyObject *_wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10845 PyObject *resultobj = 0;
10846 PLINT arg1 ;
10847 PLINT arg2 ;
10848 PLINT arg3 ;
10849 PLFLT arg4 ;
10850 int val1 ;
10851 int ecode1 = 0 ;
10852 int val2 ;
10853 int ecode2 = 0 ;
10854 int val3 ;
10855 int ecode3 = 0 ;
10856 double val4 ;
10857 int ecode4 = 0 ;
10858 PyObject *swig_obj[4] ;
10859
10860 if (!SWIG_Python_UnpackTuple(args, "plscolbga", 4, 4, swig_obj)) SWIG_fail;
10861 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10862 if (!SWIG_IsOK(ecode1)) {
10863 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
10864 }
10865 arg1 = (PLINT)(val1);
10866 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10867 if (!SWIG_IsOK(ecode2)) {
10868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
10869 }
10870 arg2 = (PLINT)(val2);
10871 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10872 if (!SWIG_IsOK(ecode3)) {
10873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
10874 }
10875 arg3 = (PLINT)(val3);
10876 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10877 if (!SWIG_IsOK(ecode4)) {
10878 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
10879 }
10880 arg4 = (PLFLT)(val4);
10881 plscolbga(arg1,arg2,arg3,arg4);
10882 resultobj = SWIG_Py_Void();
10883 return resultobj;
10884fail:
10885 return NULL;
10886}
10887
10888
10889SWIGINTERN PyObject *_wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10890 PyObject *resultobj = 0;
10891 PLINT arg1 ;
10892 int val1 ;
10893 int ecode1 = 0 ;
10894 PyObject *swig_obj[1] ;
10895
10896 if (!args) SWIG_fail;
10897 swig_obj[0] = args;
10898 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10899 if (!SWIG_IsOK(ecode1)) {
10900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
10901 }
10902 arg1 = (PLINT)(val1);
10903 plscolor(arg1);
10904 resultobj = SWIG_Py_Void();
10905 return resultobj;
10906fail:
10907 return NULL;
10908}
10909
10910
10911SWIGINTERN PyObject *_wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10912 PyObject *resultobj = 0;
10913 PLINT arg1 ;
10914 int val1 ;
10915 int ecode1 = 0 ;
10916 PyObject *swig_obj[1] ;
10917
10918 if (!args) SWIG_fail;
10919 swig_obj[0] = args;
10920 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10921 if (!SWIG_IsOK(ecode1)) {
10922 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
10923 }
10924 arg1 = (PLINT)(val1);
10925 plscompression(arg1);
10926 resultobj = SWIG_Py_Void();
10927 return resultobj;
10928fail:
10929 return NULL;
10930}
10931
10932
10933SWIGINTERN PyObject *_wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10934 PyObject *resultobj = 0;
10935 char *arg1 = (char *) 0 ;
10936 int res1 ;
10937 char *buf1 = 0 ;
10938 int alloc1 = 0 ;
10939 PyObject *swig_obj[1] ;
10940
10941 if (!args) SWIG_fail;
10942 swig_obj[0] = args;
10943 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
10944 if (!SWIG_IsOK(res1)) {
10945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
10946 }
10947 arg1 = (char *)(buf1);
10948 plsdev((char const *)arg1);
10949 resultobj = SWIG_Py_Void();
10950 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10951 return resultobj;
10952fail:
10953 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
10954 return NULL;
10955}
10956
10957
10958SWIGINTERN PyObject *_wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10959 PyObject *resultobj = 0;
10960 PLFLT arg1 ;
10961 PLFLT arg2 ;
10962 PLFLT arg3 ;
10963 PLFLT arg4 ;
10964 double val1 ;
10965 int ecode1 = 0 ;
10966 double val2 ;
10967 int ecode2 = 0 ;
10968 double val3 ;
10969 int ecode3 = 0 ;
10970 double val4 ;
10971 int ecode4 = 0 ;
10972 PyObject *swig_obj[4] ;
10973
10974 if (!SWIG_Python_UnpackTuple(args, "plsdidev", 4, 4, swig_obj)) SWIG_fail;
10975 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10976 if (!SWIG_IsOK(ecode1)) {
10977 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
10978 }
10979 arg1 = (PLFLT)(val1);
10980 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10981 if (!SWIG_IsOK(ecode2)) {
10982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
10983 }
10984 arg2 = (PLFLT)(val2);
10985 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10986 if (!SWIG_IsOK(ecode3)) {
10987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
10988 }
10989 arg3 = (PLFLT)(val3);
10990 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10991 if (!SWIG_IsOK(ecode4)) {
10992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
10993 }
10994 arg4 = (PLFLT)(val4);
10995 plsdidev(arg1,arg2,arg3,arg4);
10996 resultobj = SWIG_Py_Void();
10997 return resultobj;
10998fail:
10999 return NULL;
11000}
11001
11002
11003SWIGINTERN PyObject *_wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11004 PyObject *resultobj = 0;
11005 PLINT arg1 ;
11006 PLINT arg2 ;
11007 PLINT arg3 ;
11008 PLINT arg4 ;
11009 PLFLT arg5 ;
11010 PLFLT arg6 ;
11011 int val1 ;
11012 int ecode1 = 0 ;
11013 int val2 ;
11014 int ecode2 = 0 ;
11015 int val3 ;
11016 int ecode3 = 0 ;
11017 int val4 ;
11018 int ecode4 = 0 ;
11019 double val5 ;
11020 int ecode5 = 0 ;
11021 double val6 ;
11022 int ecode6 = 0 ;
11023 PyObject *swig_obj[6] ;
11024
11025 if (!SWIG_Python_UnpackTuple(args, "plsdimap", 6, 6, swig_obj)) SWIG_fail;
11026 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11027 if (!SWIG_IsOK(ecode1)) {
11028 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11029 }
11030 arg1 = (PLINT)(val1);
11031 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11032 if (!SWIG_IsOK(ecode2)) {
11033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11034 }
11035 arg2 = (PLINT)(val2);
11036 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11037 if (!SWIG_IsOK(ecode3)) {
11038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11039 }
11040 arg3 = (PLINT)(val3);
11041 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11042 if (!SWIG_IsOK(ecode4)) {
11043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11044 }
11045 arg4 = (PLINT)(val4);
11046 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11047 if (!SWIG_IsOK(ecode5)) {
11048 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11049 }
11050 arg5 = (PLFLT)(val5);
11051 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
11052 if (!SWIG_IsOK(ecode6)) {
11053 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11054 }
11055 arg6 = (PLFLT)(val6);
11056 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11057 resultobj = SWIG_Py_Void();
11058 return resultobj;
11059fail:
11060 return NULL;
11061}
11062
11063
11064SWIGINTERN PyObject *_wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11065 PyObject *resultobj = 0;
11066 PLFLT arg1 ;
11067 double val1 ;
11068 int ecode1 = 0 ;
11069 PyObject *swig_obj[1] ;
11070
11071 if (!args) SWIG_fail;
11072 swig_obj[0] = args;
11073 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11074 if (!SWIG_IsOK(ecode1)) {
11075 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11076 }
11077 arg1 = (PLFLT)(val1);
11078 plsdiori(arg1);
11079 resultobj = SWIG_Py_Void();
11080 return resultobj;
11081fail:
11082 return NULL;
11083}
11084
11085
11086SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11087 PyObject *resultobj = 0;
11088 PLFLT arg1 ;
11089 PLFLT arg2 ;
11090 PLFLT arg3 ;
11091 PLFLT arg4 ;
11092 double val1 ;
11093 int ecode1 = 0 ;
11094 double val2 ;
11095 int ecode2 = 0 ;
11096 double val3 ;
11097 int ecode3 = 0 ;
11098 double val4 ;
11099 int ecode4 = 0 ;
11100 PyObject *swig_obj[4] ;
11101
11102 if (!SWIG_Python_UnpackTuple(args, "plsdiplt", 4, 4, swig_obj)) SWIG_fail;
11103 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11104 if (!SWIG_IsOK(ecode1)) {
11105 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11106 }
11107 arg1 = (PLFLT)(val1);
11108 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11109 if (!SWIG_IsOK(ecode2)) {
11110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11111 }
11112 arg2 = (PLFLT)(val2);
11113 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11114 if (!SWIG_IsOK(ecode3)) {
11115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11116 }
11117 arg3 = (PLFLT)(val3);
11118 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11119 if (!SWIG_IsOK(ecode4)) {
11120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11121 }
11122 arg4 = (PLFLT)(val4);
11123 plsdiplt(arg1,arg2,arg3,arg4);
11124 resultobj = SWIG_Py_Void();
11125 return resultobj;
11126fail:
11127 return NULL;
11128}
11129
11130
11131SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11132 PyObject *resultobj = 0;
11133 PLFLT arg1 ;
11134 PLFLT arg2 ;
11135 PLFLT arg3 ;
11136 PLFLT arg4 ;
11137 double val1 ;
11138 int ecode1 = 0 ;
11139 double val2 ;
11140 int ecode2 = 0 ;
11141 double val3 ;
11142 int ecode3 = 0 ;
11143 double val4 ;
11144 int ecode4 = 0 ;
11145 PyObject *swig_obj[4] ;
11146
11147 if (!SWIG_Python_UnpackTuple(args, "plsdiplz", 4, 4, swig_obj)) SWIG_fail;
11148 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11149 if (!SWIG_IsOK(ecode1)) {
11150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11151 }
11152 arg1 = (PLFLT)(val1);
11153 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11154 if (!SWIG_IsOK(ecode2)) {
11155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11156 }
11157 arg2 = (PLFLT)(val2);
11158 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11159 if (!SWIG_IsOK(ecode3)) {
11160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11161 }
11162 arg3 = (PLFLT)(val3);
11163 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11164 if (!SWIG_IsOK(ecode4)) {
11165 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11166 }
11167 arg4 = (PLFLT)(val4);
11168 plsdiplz(arg1,arg2,arg3,arg4);
11169 resultobj = SWIG_Py_Void();
11170 return resultobj;
11171fail:
11172 return NULL;
11173}
11174
11175
11176SWIGINTERN PyObject *_wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11177 PyObject *resultobj = 0;
11178 unsigned int arg1 ;
11179 unsigned int val1 ;
11180 int ecode1 = 0 ;
11181 PyObject *swig_obj[1] ;
11182
11183 if (!args) SWIG_fail;
11184 swig_obj[0] = args;
11185 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11186 if (!SWIG_IsOK(ecode1)) {
11187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11188 }
11189 arg1 = (unsigned int)(val1);
11190 plseed(arg1);
11191 resultobj = SWIG_Py_Void();
11192 return resultobj;
11193fail:
11194 return NULL;
11195}
11196
11197
11198SWIGINTERN PyObject *_wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11199 PyObject *resultobj = 0;
11200 char arg1 ;
11201 char val1 ;
11202 int ecode1 = 0 ;
11203 PyObject *swig_obj[1] ;
11204
11205 if (!args) SWIG_fail;
11206 swig_obj[0] = args;
11207 ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
11208 if (!SWIG_IsOK(ecode1)) {
11209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11210 }
11211 arg1 = (char)(val1);
11212 plsesc(arg1);
11213 resultobj = SWIG_Py_Void();
11214 return resultobj;
11215fail:
11216 return NULL;
11217}
11218
11219
11220SWIGINTERN PyObject *_wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11221 PyObject *resultobj = 0;
11222 char *arg1 = (char *) 0 ;
11223 char *arg2 = (char *) 0 ;
11224 int res1 ;
11225 char *buf1 = 0 ;
11226 int alloc1 = 0 ;
11227 int res2 ;
11228 char *buf2 = 0 ;
11229 int alloc2 = 0 ;
11230 PyObject *swig_obj[2] ;
11231 PLINT result;
11232
11233 if (!SWIG_Python_UnpackTuple(args, "plsetopt", 2, 2, swig_obj)) SWIG_fail;
11234 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11235 if (!SWIG_IsOK(res1)) {
11236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11237 }
11238 arg1 = (char *)(buf1);
11239 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11240 if (!SWIG_IsOK(res2)) {
11241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11242 }
11243 arg2 = (char *)(buf2);
11244 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11245 resultobj = SWIG_From_int((int)(result));
11246 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11247 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11248 return resultobj;
11249fail:
11250 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11251 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11252 return NULL;
11253}
11254
11255
11256SWIGINTERN PyObject *_wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11257 PyObject *resultobj = 0;
11258 PLINT arg1 ;
11259 PLINT arg2 ;
11260 PLINT arg3 ;
11261 int val1 ;
11262 int ecode1 = 0 ;
11263 int val2 ;
11264 int ecode2 = 0 ;
11265 int val3 ;
11266 int ecode3 = 0 ;
11267 PyObject *swig_obj[3] ;
11268
11269 if (!SWIG_Python_UnpackTuple(args, "plsfam", 3, 3, swig_obj)) SWIG_fail;
11270 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11271 if (!SWIG_IsOK(ecode1)) {
11272 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11273 }
11274 arg1 = (PLINT)(val1);
11275 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11276 if (!SWIG_IsOK(ecode2)) {
11277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11278 }
11279 arg2 = (PLINT)(val2);
11280 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11281 if (!SWIG_IsOK(ecode3)) {
11282 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11283 }
11284 arg3 = (PLINT)(val3);
11285 plsfam(arg1,arg2,arg3);
11286 resultobj = SWIG_Py_Void();
11287 return resultobj;
11288fail:
11289 return NULL;
11290}
11291
11292
11293SWIGINTERN PyObject *_wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11294 PyObject *resultobj = 0;
11295 PLUNICODE arg1 ;
11296 unsigned int val1 ;
11297 int ecode1 = 0 ;
11298 PyObject *swig_obj[1] ;
11299
11300 if (!args) SWIG_fail;
11301 swig_obj[0] = args;
11302 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11303 if (!SWIG_IsOK(ecode1)) {
11304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11305 }
11306 arg1 = (PLUNICODE)(val1);
11307 plsfci(arg1);
11308 resultobj = SWIG_Py_Void();
11309 return resultobj;
11310fail:
11311 return NULL;
11312}
11313
11314
11315SWIGINTERN PyObject *_wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11316 PyObject *resultobj = 0;
11317 char *arg1 = (char *) 0 ;
11318 int res1 ;
11319 char *buf1 = 0 ;
11320 int alloc1 = 0 ;
11321 PyObject *swig_obj[1] ;
11322
11323 if (!args) SWIG_fail;
11324 swig_obj[0] = args;
11325 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11326 if (!SWIG_IsOK(res1)) {
11327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11328 }
11329 arg1 = (char *)(buf1);
11330 plsfnam((char const *)arg1);
11331 resultobj = SWIG_Py_Void();
11332 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11333 return resultobj;
11334fail:
11335 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11336 return NULL;
11337}
11338
11339
11340SWIGINTERN PyObject *_wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11341 PyObject *resultobj = 0;
11342 PLINT arg1 ;
11343 PLINT arg2 ;
11344 PLINT arg3 ;
11345 int val1 ;
11346 int ecode1 = 0 ;
11347 int val2 ;
11348 int ecode2 = 0 ;
11349 int val3 ;
11350 int ecode3 = 0 ;
11351 PyObject *swig_obj[3] ;
11352
11353 if (!SWIG_Python_UnpackTuple(args, "plsfont", 3, 3, swig_obj)) SWIG_fail;
11354 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11355 if (!SWIG_IsOK(ecode1)) {
11356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11357 }
11358 arg1 = (PLINT)(val1);
11359 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11360 if (!SWIG_IsOK(ecode2)) {
11361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11362 }
11363 arg2 = (PLINT)(val2);
11364 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11365 if (!SWIG_IsOK(ecode3)) {
11366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11367 }
11368 arg3 = (PLINT)(val3);
11369 plsfont(arg1,arg2,arg3);
11370 resultobj = SWIG_Py_Void();
11371 return resultobj;
11372fail:
11373 return NULL;
11374}
11375
11376
11377SWIGINTERN PyObject *_wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11378 PyObject *resultobj = 0;
11379 PLFLT **arg1 = (PLFLT **) 0 ;
11380 PLINT arg2 ;
11381 PLINT arg3 ;
11382 defined_func arg4 = (defined_func) 0 ;
11383 PLFLT arg5 ;
11384 PLFLT arg6 ;
11385 PLFLT arg7 ;
11386 PLFLT arg8 ;
11387 PLFLT *arg9 = (PLFLT *) 0 ;
11388 PLINT arg10 ;
11389 PLFLT arg11 ;
11390 PLINT arg12 ;
11391 PLFLT arg13 ;
11392 fill_func arg14 = (fill_func) 0 ;
11393 PLBOOL arg15 ;
11394 pltr_func arg16 = (pltr_func) 0 ;
11395 PLPointer arg17 = (PLPointer) 0 ;
11396 PyArrayObject *tmp1 = NULL ;
11397 double val5 ;
11398 int ecode5 = 0 ;
11399 double val6 ;
11400 int ecode6 = 0 ;
11401 double val7 ;
11402 int ecode7 = 0 ;
11403 double val8 ;
11404 int ecode8 = 0 ;
11405 PyArrayObject *tmp9 = NULL ;
11406 double val11 ;
11407 int ecode11 = 0 ;
11408 int val12 ;
11409 int ecode12 = 0 ;
11410 double val13 ;
11411 int ecode13 = 0 ;
11412 int val15 ;
11413 int ecode15 = 0 ;
11414 PyObject *swig_obj[12] ;
11415
11416 {
11417 python_pltr = 0;
11418 arg16 = NULL;
11419 }
11420 {
11421 arg17 = NULL;
11422 }
11423 {
11424 arg4 = NULL;
11425 }
11426 {
11427 arg14 = plfill;
11428 }
11429 if (!SWIG_Python_UnpackTuple(args, "plshades", 10, 12, swig_obj)) SWIG_fail;
11430 {
11431 int i, size;
11432 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
11433 if ( tmp1 == NULL )
11434 return NULL;
11435 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11436 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11437 size = arg3;
11438 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11439 for ( i = 0; i < arg2; i++ )
11440 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11441 }
11442 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
11443 if (!SWIG_IsOK(ecode5)) {
11444 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11445 }
11446 arg5 = (PLFLT)(val5);
11447 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
11448 if (!SWIG_IsOK(ecode6)) {
11449 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11450 }
11451 arg6 = (PLFLT)(val6);
11452 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
11453 if (!SWIG_IsOK(ecode7)) {
11454 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11455 }
11456 arg7 = (PLFLT)(val7);
11457 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
11458 if (!SWIG_IsOK(ecode8)) {
11459 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11460 }
11461 arg8 = (PLFLT)(val8);
11462 {
11463 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
11464 if ( tmp9 == NULL )
11465 return NULL;
11466 arg10 = PyArray_DIMS( tmp9 )[0];
11467 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11468 }
11469 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
11470 if (!SWIG_IsOK(ecode11)) {
11471 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
11472 }
11473 arg11 = (PLFLT)(val11);
11474 ecode12 = SWIG_AsVal_int(swig_obj[7], &val12);
11475 if (!SWIG_IsOK(ecode12)) {
11476 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11477 }
11478 arg12 = (PLINT)(val12);
11479 ecode13 = SWIG_AsVal_double(swig_obj[8], &val13);
11480 if (!SWIG_IsOK(ecode13)) {
11481 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
11482 }
11483 arg13 = (PLFLT)(val13);
11484 ecode15 = SWIG_AsVal_int(swig_obj[9], &val15);
11485 if (!SWIG_IsOK(ecode15)) {
11486 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11487 }
11488 arg15 = (PLBOOL)(val15);
11489 if (swig_obj[10]) {
11490 {
11491 // it must be a callable or None
11492 if ( swig_obj[10] == Py_None )
11493 {
11494 arg16 = NULL;
11495 }
11496 else
11497 {
11498 if ( !PyCallable_Check( (PyObject *) swig_obj[10] ) )
11499 {
11500 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11501 return NULL;
11502 }
11503 arg16 = marshal_pltr( swig_obj[10] );
11504 }
11505 }
11506 }
11507 if (swig_obj[11]) {
11508 {
11509 if ( swig_obj[11] == Py_None )
11510 arg17 = NULL;
11511 else
11512 {
11513 arg17 = marshal_PLPointer( swig_obj[11], 0 );
11514 }
11515 }
11516 }
11517 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11518 resultobj = SWIG_Py_Void();
11519 {
11520 Py_CLEAR( tmp1 );
11521 free( arg1 );
11522 }
11523 {
11524 Py_CLEAR( tmp9 );
11525 }
11526 {
11527 cleanup_pltr();
11528 }
11529 {
11531 }
11532 return resultobj;
11533fail:
11534 {
11535 Py_CLEAR( tmp1 );
11536 free( arg1 );
11537 }
11538 {
11539 Py_CLEAR( tmp9 );
11540 }
11541 {
11542 cleanup_pltr();
11543 }
11544 {
11546 }
11547 return NULL;
11548}
11549
11550
11551SWIGINTERN PyObject *_wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11552 PyObject *resultobj = 0;
11553 PLFLT **arg1 = (PLFLT **) 0 ;
11554 PLINT arg2 ;
11555 PLINT arg3 ;
11556 defined_func arg4 = (defined_func) 0 ;
11557 PLFLT arg5 ;
11558 PLFLT arg6 ;
11559 PLFLT arg7 ;
11560 PLFLT arg8 ;
11561 PLFLT arg9 ;
11562 PLFLT arg10 ;
11563 PLINT arg11 ;
11564 PLFLT arg12 ;
11565 PLFLT arg13 ;
11566 PLINT arg14 ;
11567 PLFLT arg15 ;
11568 PLINT arg16 ;
11569 PLFLT arg17 ;
11570 fill_func arg18 = (fill_func) 0 ;
11571 PLBOOL arg19 ;
11572 pltr_func arg20 = (pltr_func) 0 ;
11573 PLPointer arg21 = (PLPointer) 0 ;
11574 PyArrayObject *tmp1 = NULL ;
11575 double val5 ;
11576 int ecode5 = 0 ;
11577 double val6 ;
11578 int ecode6 = 0 ;
11579 double val7 ;
11580 int ecode7 = 0 ;
11581 double val8 ;
11582 int ecode8 = 0 ;
11583 double val9 ;
11584 int ecode9 = 0 ;
11585 double val10 ;
11586 int ecode10 = 0 ;
11587 int val11 ;
11588 int ecode11 = 0 ;
11589 double val12 ;
11590 int ecode12 = 0 ;
11591 double val13 ;
11592 int ecode13 = 0 ;
11593 int val14 ;
11594 int ecode14 = 0 ;
11595 double val15 ;
11596 int ecode15 = 0 ;
11597 int val16 ;
11598 int ecode16 = 0 ;
11599 double val17 ;
11600 int ecode17 = 0 ;
11601 int val19 ;
11602 int ecode19 = 0 ;
11603 PyObject *swig_obj[17] ;
11604
11605 {
11606 python_pltr = 0;
11607 arg20 = NULL;
11608 }
11609 {
11610 arg21 = NULL;
11611 }
11612 {
11613 arg4 = NULL;
11614 }
11615 {
11616 arg18 = plfill;
11617 }
11618 if (!SWIG_Python_UnpackTuple(args, "plshade", 15, 17, swig_obj)) SWIG_fail;
11619 {
11620 int i, size;
11621 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
11622 if ( tmp1 == NULL )
11623 return NULL;
11624 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11625 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11626 size = arg3;
11627 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11628 for ( i = 0; i < arg2; i++ )
11629 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11630 }
11631 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
11632 if (!SWIG_IsOK(ecode5)) {
11633 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
11634 }
11635 arg5 = (PLFLT)(val5);
11636 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
11637 if (!SWIG_IsOK(ecode6)) {
11638 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
11639 }
11640 arg6 = (PLFLT)(val6);
11641 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
11642 if (!SWIG_IsOK(ecode7)) {
11643 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
11644 }
11645 arg7 = (PLFLT)(val7);
11646 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
11647 if (!SWIG_IsOK(ecode8)) {
11648 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
11649 }
11650 arg8 = (PLFLT)(val8);
11651 ecode9 = SWIG_AsVal_double(swig_obj[5], &val9);
11652 if (!SWIG_IsOK(ecode9)) {
11653 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
11654 }
11655 arg9 = (PLFLT)(val9);
11656 ecode10 = SWIG_AsVal_double(swig_obj[6], &val10);
11657 if (!SWIG_IsOK(ecode10)) {
11658 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
11659 }
11660 arg10 = (PLFLT)(val10);
11661 ecode11 = SWIG_AsVal_int(swig_obj[7], &val11);
11662 if (!SWIG_IsOK(ecode11)) {
11663 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
11664 }
11665 arg11 = (PLINT)(val11);
11666 ecode12 = SWIG_AsVal_double(swig_obj[8], &val12);
11667 if (!SWIG_IsOK(ecode12)) {
11668 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
11669 }
11670 arg12 = (PLFLT)(val12);
11671 ecode13 = SWIG_AsVal_double(swig_obj[9], &val13);
11672 if (!SWIG_IsOK(ecode13)) {
11673 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
11674 }
11675 arg13 = (PLFLT)(val13);
11676 ecode14 = SWIG_AsVal_int(swig_obj[10], &val14);
11677 if (!SWIG_IsOK(ecode14)) {
11678 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
11679 }
11680 arg14 = (PLINT)(val14);
11681 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
11682 if (!SWIG_IsOK(ecode15)) {
11683 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
11684 }
11685 arg15 = (PLFLT)(val15);
11686 ecode16 = SWIG_AsVal_int(swig_obj[12], &val16);
11687 if (!SWIG_IsOK(ecode16)) {
11688 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
11689 }
11690 arg16 = (PLINT)(val16);
11691 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
11692 if (!SWIG_IsOK(ecode17)) {
11693 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
11694 }
11695 arg17 = (PLFLT)(val17);
11696 ecode19 = SWIG_AsVal_int(swig_obj[14], &val19);
11697 if (!SWIG_IsOK(ecode19)) {
11698 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
11699 }
11700 arg19 = (PLBOOL)(val19);
11701 if (swig_obj[15]) {
11702 {
11703 // it must be a callable or None
11704 if ( swig_obj[15] == Py_None )
11705 {
11706 arg20 = NULL;
11707 }
11708 else
11709 {
11710 if ( !PyCallable_Check( (PyObject *) swig_obj[15] ) )
11711 {
11712 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11713 return NULL;
11714 }
11715 arg20 = marshal_pltr( swig_obj[15] );
11716 }
11717 }
11718 }
11719 if (swig_obj[16]) {
11720 {
11721 if ( swig_obj[16] == Py_None )
11722 arg21 = NULL;
11723 else
11724 {
11725 arg21 = marshal_PLPointer( swig_obj[16], 0 );
11726 }
11727 }
11728 }
11729 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
11730 resultobj = SWIG_Py_Void();
11731 {
11732 Py_CLEAR( tmp1 );
11733 free( arg1 );
11734 }
11735 {
11736 cleanup_pltr();
11737 }
11738 {
11740 }
11741 return resultobj;
11742fail:
11743 {
11744 Py_CLEAR( tmp1 );
11745 free( arg1 );
11746 }
11747 {
11748 cleanup_pltr();
11749 }
11750 {
11752 }
11753 return NULL;
11754}
11755
11756
11757SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11758 PyObject *resultobj = 0;
11759 label_func arg1 = (label_func) 0 ;
11760 PLPointer arg2 = (PLPointer) 0 ;
11761 int res2 ;
11762 PyObject *swig_obj[2] ;
11763
11764 if (!SWIG_Python_UnpackTuple(args, "plslabelfunc", 2, 2, swig_obj)) SWIG_fail;
11765 {
11766 // Release reference to previous function if applicable
11767 if ( python_label )
11768 {
11769 Py_CLEAR( python_label );
11770 python_label = 0;
11771 }
11772 // it must be a callable or None
11773 if ( swig_obj[0] == Py_None )
11774 {
11775 arg1 = NULL;
11776 }
11777 else
11778 {
11779 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
11780 {
11781 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
11782 return NULL;
11783 }
11784 // hold a reference to it
11785 Py_XINCREF( (PyObject *) swig_obj[0] );
11786 python_label = (PyObject *) swig_obj[0];
11787 // this function handles calling the python function
11788 arg1 = do_label_callback;
11789 }
11790 }
11791 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
11792 if (!SWIG_IsOK(res2)) {
11793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
11794 }
11795 plslabelfunc(arg1,arg2);
11796 resultobj = SWIG_Py_Void();
11797 return resultobj;
11798fail:
11799 return NULL;
11800}
11801
11802
11803SWIGINTERN PyObject *_wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11804 PyObject *resultobj = 0;
11805 PLFLT arg1 ;
11806 PLFLT arg2 ;
11807 double val1 ;
11808 int ecode1 = 0 ;
11809 double val2 ;
11810 int ecode2 = 0 ;
11811 PyObject *swig_obj[2] ;
11812
11813 if (!SWIG_Python_UnpackTuple(args, "plsmaj", 2, 2, swig_obj)) SWIG_fail;
11814 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11815 if (!SWIG_IsOK(ecode1)) {
11816 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
11817 }
11818 arg1 = (PLFLT)(val1);
11819 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11820 if (!SWIG_IsOK(ecode2)) {
11821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
11822 }
11823 arg2 = (PLFLT)(val2);
11824 plsmaj(arg1,arg2);
11825 resultobj = SWIG_Py_Void();
11826 return resultobj;
11827fail:
11828 return NULL;
11829}
11830
11831
11832SWIGINTERN PyObject *_wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11833 PyObject *resultobj = 0;
11834 PLINT arg1 ;
11835 PLINT arg2 ;
11836 void *arg3 = (void *) 0 ;
11837 int val1 ;
11838 int ecode1 = 0 ;
11839 int val2 ;
11840 int ecode2 = 0 ;
11841 PyObject *swig_obj[3] ;
11842
11843 if (!SWIG_Python_UnpackTuple(args, "plsmem", 3, 3, swig_obj)) SWIG_fail;
11844 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11845 if (!SWIG_IsOK(ecode1)) {
11846 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
11847 }
11848 arg1 = (PLINT)(val1);
11849 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11850 if (!SWIG_IsOK(ecode2)) {
11851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
11852 }
11853 arg2 = (PLINT)(val2);
11854 {
11855 int res; void *buf = 0;
11856 Py_buffer view;
11857 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
11858 buf = view.buf;
11859 PyBuffer_Release(&view);
11860 if (res < 0) {
11861 PyErr_Clear();
11862 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem)""'");
11863 }
11864 arg3 = (void *) buf;
11865 }
11866 plsmem(arg1,arg2,arg3);
11867 resultobj = SWIG_Py_Void();
11868 return resultobj;
11869fail:
11870 return NULL;
11871}
11872
11873
11874SWIGINTERN PyObject *_wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11875 PyObject *resultobj = 0;
11876 PLINT arg1 ;
11877 PLINT arg2 ;
11878 void *arg3 = (void *) 0 ;
11879 int val1 ;
11880 int ecode1 = 0 ;
11881 int val2 ;
11882 int ecode2 = 0 ;
11883 PyObject *swig_obj[3] ;
11884
11885 if (!SWIG_Python_UnpackTuple(args, "plsmema", 3, 3, swig_obj)) SWIG_fail;
11886 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11887 if (!SWIG_IsOK(ecode1)) {
11888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
11889 }
11890 arg1 = (PLINT)(val1);
11891 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11892 if (!SWIG_IsOK(ecode2)) {
11893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
11894 }
11895 arg2 = (PLINT)(val2);
11896 {
11897 int res; void *buf = 0;
11898 Py_buffer view;
11899 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
11900 buf = view.buf;
11901 PyBuffer_Release(&view);
11902 if (res < 0) {
11903 PyErr_Clear();
11904 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem)""'");
11905 }
11906 arg3 = (void *) buf;
11907 }
11908 plsmema(arg1,arg2,arg3);
11909 resultobj = SWIG_Py_Void();
11910 return resultobj;
11911fail:
11912 return NULL;
11913}
11914
11915
11916SWIGINTERN PyObject *_wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11917 PyObject *resultobj = 0;
11918 PLFLT arg1 ;
11919 PLFLT arg2 ;
11920 double val1 ;
11921 int ecode1 = 0 ;
11922 double val2 ;
11923 int ecode2 = 0 ;
11924 PyObject *swig_obj[2] ;
11925
11926 if (!SWIG_Python_UnpackTuple(args, "plsmin", 2, 2, swig_obj)) SWIG_fail;
11927 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11928 if (!SWIG_IsOK(ecode1)) {
11929 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
11930 }
11931 arg1 = (PLFLT)(val1);
11932 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11933 if (!SWIG_IsOK(ecode2)) {
11934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
11935 }
11936 arg2 = (PLFLT)(val2);
11937 plsmin(arg1,arg2);
11938 resultobj = SWIG_Py_Void();
11939 return resultobj;
11940fail:
11941 return NULL;
11942}
11943
11944
11945SWIGINTERN PyObject *_wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11946 PyObject *resultobj = 0;
11947 PLINT arg1 ;
11948 int val1 ;
11949 int ecode1 = 0 ;
11950 PyObject *swig_obj[1] ;
11951
11952 if (!args) SWIG_fail;
11953 swig_obj[0] = args;
11954 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11955 if (!SWIG_IsOK(ecode1)) {
11956 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
11957 }
11958 arg1 = (PLINT)(val1);
11959 plsori(arg1);
11960 resultobj = SWIG_Py_Void();
11961 return resultobj;
11962fail:
11963 return NULL;
11964}
11965
11966
11967SWIGINTERN PyObject *_wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11968 PyObject *resultobj = 0;
11969 PLFLT arg1 ;
11970 PLFLT arg2 ;
11971 PLINT arg3 ;
11972 PLINT arg4 ;
11973 PLINT arg5 ;
11974 PLINT arg6 ;
11975 double val1 ;
11976 int ecode1 = 0 ;
11977 double val2 ;
11978 int ecode2 = 0 ;
11979 int val3 ;
11980 int ecode3 = 0 ;
11981 int val4 ;
11982 int ecode4 = 0 ;
11983 int val5 ;
11984 int ecode5 = 0 ;
11985 int val6 ;
11986 int ecode6 = 0 ;
11987 PyObject *swig_obj[6] ;
11988
11989 if (!SWIG_Python_UnpackTuple(args, "plspage", 6, 6, swig_obj)) SWIG_fail;
11990 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11991 if (!SWIG_IsOK(ecode1)) {
11992 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
11993 }
11994 arg1 = (PLFLT)(val1);
11995 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11996 if (!SWIG_IsOK(ecode2)) {
11997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
11998 }
11999 arg2 = (PLFLT)(val2);
12000 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12001 if (!SWIG_IsOK(ecode3)) {
12002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12003 }
12004 arg3 = (PLINT)(val3);
12005 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
12006 if (!SWIG_IsOK(ecode4)) {
12007 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12008 }
12009 arg4 = (PLINT)(val4);
12010 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
12011 if (!SWIG_IsOK(ecode5)) {
12012 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12013 }
12014 arg5 = (PLINT)(val5);
12015 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
12016 if (!SWIG_IsOK(ecode6)) {
12017 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12018 }
12019 arg6 = (PLINT)(val6);
12020 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12021 resultobj = SWIG_Py_Void();
12022 return resultobj;
12023fail:
12024 return NULL;
12025}
12026
12027
12028SWIGINTERN PyObject *_wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12029 PyObject *resultobj = 0;
12030 char *arg1 = (char *) 0 ;
12031 int res1 ;
12032 char *buf1 = 0 ;
12033 int alloc1 = 0 ;
12034 PyObject *swig_obj[1] ;
12035
12036 if (!args) SWIG_fail;
12037 swig_obj[0] = args;
12038 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12039 if (!SWIG_IsOK(res1)) {
12040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12041 }
12042 arg1 = (char *)(buf1);
12043 plspal0((char const *)arg1);
12044 resultobj = SWIG_Py_Void();
12045 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12046 return resultobj;
12047fail:
12048 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12049 return NULL;
12050}
12051
12052
12053SWIGINTERN PyObject *_wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12054 PyObject *resultobj = 0;
12055 char *arg1 = (char *) 0 ;
12056 PLBOOL arg2 ;
12057 int res1 ;
12058 char *buf1 = 0 ;
12059 int alloc1 = 0 ;
12060 int val2 ;
12061 int ecode2 = 0 ;
12062 PyObject *swig_obj[2] ;
12063
12064 if (!SWIG_Python_UnpackTuple(args, "plspal1", 2, 2, swig_obj)) SWIG_fail;
12065 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12066 if (!SWIG_IsOK(res1)) {
12067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12068 }
12069 arg1 = (char *)(buf1);
12070 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12071 if (!SWIG_IsOK(ecode2)) {
12072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12073 }
12074 arg2 = (PLBOOL)(val2);
12075 plspal1((char const *)arg1,arg2);
12076 resultobj = SWIG_Py_Void();
12077 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12078 return resultobj;
12079fail:
12080 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12081 return NULL;
12082}
12083
12084
12085SWIGINTERN PyObject *_wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12086 PyObject *resultobj = 0;
12087 PLBOOL arg1 ;
12088 int val1 ;
12089 int ecode1 = 0 ;
12090 PyObject *swig_obj[1] ;
12091
12092 if (!args) SWIG_fail;
12093 swig_obj[0] = args;
12094 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12095 if (!SWIG_IsOK(ecode1)) {
12096 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12097 }
12098 arg1 = (PLBOOL)(val1);
12099 plspause(arg1);
12100 resultobj = SWIG_Py_Void();
12101 return resultobj;
12102fail:
12103 return NULL;
12104}
12105
12106
12107SWIGINTERN PyObject *_wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12108 PyObject *resultobj = 0;
12109 PLINT arg1 ;
12110 int val1 ;
12111 int ecode1 = 0 ;
12112 PyObject *swig_obj[1] ;
12113
12114 if (!args) SWIG_fail;
12115 swig_obj[0] = args;
12116 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12117 if (!SWIG_IsOK(ecode1)) {
12118 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12119 }
12120 arg1 = (PLINT)(val1);
12121 plsstrm(arg1);
12122 resultobj = SWIG_Py_Void();
12123 return resultobj;
12124fail:
12125 return NULL;
12126}
12127
12128
12129SWIGINTERN PyObject *_wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12130 PyObject *resultobj = 0;
12131 PLINT arg1 ;
12132 PLINT arg2 ;
12133 int val1 ;
12134 int ecode1 = 0 ;
12135 int val2 ;
12136 int ecode2 = 0 ;
12137 PyObject *swig_obj[2] ;
12138
12139 if (!SWIG_Python_UnpackTuple(args, "plssub", 2, 2, swig_obj)) SWIG_fail;
12140 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12141 if (!SWIG_IsOK(ecode1)) {
12142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12143 }
12144 arg1 = (PLINT)(val1);
12145 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12146 if (!SWIG_IsOK(ecode2)) {
12147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12148 }
12149 arg2 = (PLINT)(val2);
12150 plssub(arg1,arg2);
12151 resultobj = SWIG_Py_Void();
12152 return resultobj;
12153fail:
12154 return NULL;
12155}
12156
12157
12158SWIGINTERN PyObject *_wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12159 PyObject *resultobj = 0;
12160 PLFLT arg1 ;
12161 PLFLT arg2 ;
12162 double val1 ;
12163 int ecode1 = 0 ;
12164 double val2 ;
12165 int ecode2 = 0 ;
12166 PyObject *swig_obj[2] ;
12167
12168 if (!SWIG_Python_UnpackTuple(args, "plssym", 2, 2, swig_obj)) SWIG_fail;
12169 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12170 if (!SWIG_IsOK(ecode1)) {
12171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12172 }
12173 arg1 = (PLFLT)(val1);
12174 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12175 if (!SWIG_IsOK(ecode2)) {
12176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12177 }
12178 arg2 = (PLFLT)(val2);
12179 plssym(arg1,arg2);
12180 resultobj = SWIG_Py_Void();
12181 return resultobj;
12182fail:
12183 return NULL;
12184}
12185
12186
12187SWIGINTERN PyObject *_wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12188 PyObject *resultobj = 0;
12189 PLINT arg1 ;
12190 PLINT arg2 ;
12191 int val1 ;
12192 int ecode1 = 0 ;
12193 int val2 ;
12194 int ecode2 = 0 ;
12195 PyObject *swig_obj[2] ;
12196
12197 if (!SWIG_Python_UnpackTuple(args, "plstar", 2, 2, swig_obj)) SWIG_fail;
12198 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12199 if (!SWIG_IsOK(ecode1)) {
12200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12201 }
12202 arg1 = (PLINT)(val1);
12203 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12204 if (!SWIG_IsOK(ecode2)) {
12205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12206 }
12207 arg2 = (PLINT)(val2);
12208 plstar(arg1,arg2);
12209 resultobj = SWIG_Py_Void();
12210 return resultobj;
12211fail:
12212 return NULL;
12213}
12214
12215
12216SWIGINTERN PyObject *_wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12217 PyObject *resultobj = 0;
12218 char *arg1 = (char *) 0 ;
12219 PLINT arg2 ;
12220 PLINT arg3 ;
12221 int res1 ;
12222 char *buf1 = 0 ;
12223 int alloc1 = 0 ;
12224 int val2 ;
12225 int ecode2 = 0 ;
12226 int val3 ;
12227 int ecode3 = 0 ;
12228 PyObject *swig_obj[3] ;
12229
12230 if (!SWIG_Python_UnpackTuple(args, "plstart", 3, 3, swig_obj)) SWIG_fail;
12231 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12232 if (!SWIG_IsOK(res1)) {
12233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12234 }
12235 arg1 = (char *)(buf1);
12236 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12237 if (!SWIG_IsOK(ecode2)) {
12238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12239 }
12240 arg2 = (PLINT)(val2);
12241 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12242 if (!SWIG_IsOK(ecode3)) {
12243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12244 }
12245 arg3 = (PLINT)(val3);
12246 plstart((char const *)arg1,arg2,arg3);
12247 resultobj = SWIG_Py_Void();
12248 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12249 return resultobj;
12250fail:
12251 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12252 return NULL;
12253}
12254
12255
12256SWIGINTERN PyObject *_wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12257 PyObject *resultobj = 0;
12258 ct_func arg1 = (ct_func) 0 ;
12259 PLPointer arg2 = (PLPointer) 0 ;
12260 int res2 ;
12261 PyObject *swig_obj[2] ;
12262
12263 {
12264 python_ct = 0;
12265 arg1 = NULL;
12266 }
12267 if (!SWIG_Python_UnpackTuple(args, "plstransform", 0, 2, swig_obj)) SWIG_fail;
12268 if (swig_obj[0]) {
12269 {
12270 if ( python_ct )
12271 cleanup_ct();
12272 // it must be a callable or none
12273 if ( swig_obj[0] == Py_None )
12274 {
12275 arg1 = NULL;
12276 }
12277 else
12278 {
12279 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12280 {
12281 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12282 return NULL;
12283 }
12284 arg1 = marshal_ct( swig_obj[0] );
12285 }
12286 }
12287 }
12288 if (swig_obj[1]) {
12289 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12290 if (!SWIG_IsOK(res2)) {
12291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12292 }
12293 }
12294 plstransform(arg1,arg2);
12295 resultobj = SWIG_Py_Void();
12296 return resultobj;
12297fail:
12298 return NULL;
12299}
12300
12301
12302SWIGINTERN PyObject *_wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12303 PyObject *resultobj = 0;
12304 PLINT arg1 ;
12305 PLFLT *arg2 = (PLFLT *) 0 ;
12306 PLFLT *arg3 = (PLFLT *) 0 ;
12307 char *arg4 = (char *) 0 ;
12308 PyArrayObject *tmp1 = NULL ;
12309 PyArrayObject *tmp3 = NULL ;
12310 int res4 ;
12311 char *buf4 = 0 ;
12312 int alloc4 = 0 ;
12313 PyObject *swig_obj[3] ;
12314
12315 if (!SWIG_Python_UnpackTuple(args, "plstring", 3, 3, swig_obj)) SWIG_fail;
12316 {
12317 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12318 if ( tmp1 == NULL )
12319 return NULL;
12320 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12321 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12322 }
12323 {
12324 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12325 if ( tmp3 == NULL )
12326 return NULL;
12327 if ( PyArray_DIMS( tmp3 )[0] != Alen )
12328 {
12329 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12330 return NULL;
12331 }
12332 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12333 }
12334 res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
12335 if (!SWIG_IsOK(res4)) {
12336 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12337 }
12338 arg4 = (char *)(buf4);
12339 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12340 resultobj = SWIG_Py_Void();
12341 {
12342 Py_CLEAR( tmp1 );
12343 }
12344 {
12345 Py_CLEAR( tmp3 );
12346 }
12347 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12348 return resultobj;
12349fail:
12350 {
12351 Py_CLEAR( tmp1 );
12352 }
12353 {
12354 Py_CLEAR( tmp3 );
12355 }
12356 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12357 return NULL;
12358}
12359
12360
12361SWIGINTERN PyObject *_wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12362 PyObject *resultobj = 0;
12363 PLINT arg1 ;
12364 PLFLT *arg2 = (PLFLT *) 0 ;
12365 PLFLT *arg3 = (PLFLT *) 0 ;
12366 PLFLT *arg4 = (PLFLT *) 0 ;
12367 char *arg5 = (char *) 0 ;
12368 PyArrayObject *tmp1 = NULL ;
12369 PyArrayObject *tmp3 = NULL ;
12370 PyArrayObject *tmp4 = NULL ;
12371 int res5 ;
12372 char *buf5 = 0 ;
12373 int alloc5 = 0 ;
12374 PyObject *swig_obj[4] ;
12375
12376 if (!SWIG_Python_UnpackTuple(args, "plstring3", 4, 4, swig_obj)) SWIG_fail;
12377 {
12378 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12379 if ( tmp1 == NULL )
12380 return NULL;
12381 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12382 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12383 }
12384 {
12385 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12386 if ( tmp3 == NULL )
12387 return NULL;
12388 if ( PyArray_DIMS( tmp3 )[0] != Alen )
12389 {
12390 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12391 return NULL;
12392 }
12393 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12394 }
12395 {
12396 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
12397 if ( tmp4 == NULL )
12398 return NULL;
12399 if ( PyArray_DIMS( tmp4 )[0] != Alen )
12400 {
12401 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12402 return NULL;
12403 }
12404 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12405 }
12406 res5 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf5, NULL, &alloc5);
12407 if (!SWIG_IsOK(res5)) {
12408 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12409 }
12410 arg5 = (char *)(buf5);
12411 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12412 resultobj = SWIG_Py_Void();
12413 {
12414 Py_CLEAR( tmp1 );
12415 }
12416 {
12417 Py_CLEAR( tmp3 );
12418 }
12419 {
12420 Py_CLEAR( tmp4 );
12421 }
12422 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12423 return resultobj;
12424fail:
12425 {
12426 Py_CLEAR( tmp1 );
12427 }
12428 {
12429 Py_CLEAR( tmp3 );
12430 }
12431 {
12432 Py_CLEAR( tmp4 );
12433 }
12434 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12435 return NULL;
12436}
12437
12438
12439SWIGINTERN PyObject *_wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12440 PyObject *resultobj = 0;
12441 PLINT arg1 ;
12442 PLINT arg2 ;
12443 PLFLT arg3 ;
12444 PLFLT arg4 ;
12445 int val1 ;
12446 int ecode1 = 0 ;
12447 int val2 ;
12448 int ecode2 = 0 ;
12449 double val3 ;
12450 int ecode3 = 0 ;
12451 double val4 ;
12452 int ecode4 = 0 ;
12453 PyObject *swig_obj[4] ;
12454
12455 if (!SWIG_Python_UnpackTuple(args, "plstripa", 4, 4, swig_obj)) SWIG_fail;
12456 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12457 if (!SWIG_IsOK(ecode1)) {
12458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12459 }
12460 arg1 = (PLINT)(val1);
12461 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12462 if (!SWIG_IsOK(ecode2)) {
12463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12464 }
12465 arg2 = (PLINT)(val2);
12466 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
12467 if (!SWIG_IsOK(ecode3)) {
12468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12469 }
12470 arg3 = (PLFLT)(val3);
12471 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
12472 if (!SWIG_IsOK(ecode4)) {
12473 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12474 }
12475 arg4 = (PLFLT)(val4);
12476 plstripa(arg1,arg2,arg3,arg4);
12477 resultobj = SWIG_Py_Void();
12478 return resultobj;
12479fail:
12480 return NULL;
12481}
12482
12483
12484SWIGINTERN PyObject *_wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12485 PyObject *resultobj = 0;
12486 PLINT *arg1 = (PLINT *) 0 ;
12487 char *arg2 = (char *) 0 ;
12488 char *arg3 = (char *) 0 ;
12489 PLFLT arg4 ;
12490 PLFLT arg5 ;
12491 PLFLT arg6 ;
12492 PLFLT arg7 ;
12493 PLFLT arg8 ;
12494 PLFLT arg9 ;
12495 PLFLT arg10 ;
12496 PLBOOL arg11 ;
12497 PLBOOL arg12 ;
12498 PLINT arg13 ;
12499 PLINT arg14 ;
12500 PLINT *arg15 = (PLINT *) 0 ;
12501 PLINT *arg16 = (PLINT *) 0 ;
12502 char **arg17 ;
12503 char *arg18 = (char *) 0 ;
12504 char *arg19 = (char *) 0 ;
12505 char *arg20 = (char *) 0 ;
12506 PLINT temp1 ;
12507 int res1 = SWIG_TMPOBJ ;
12508 int res2 ;
12509 char *buf2 = 0 ;
12510 int alloc2 = 0 ;
12511 int res3 ;
12512 char *buf3 = 0 ;
12513 int alloc3 = 0 ;
12514 double val4 ;
12515 int ecode4 = 0 ;
12516 double val5 ;
12517 int ecode5 = 0 ;
12518 double val6 ;
12519 int ecode6 = 0 ;
12520 double val7 ;
12521 int ecode7 = 0 ;
12522 double val8 ;
12523 int ecode8 = 0 ;
12524 double val9 ;
12525 int ecode9 = 0 ;
12526 double val10 ;
12527 int ecode10 = 0 ;
12528 int val11 ;
12529 int ecode11 = 0 ;
12530 int val12 ;
12531 int ecode12 = 0 ;
12532 int val13 ;
12533 int ecode13 = 0 ;
12534 int val14 ;
12535 int ecode14 = 0 ;
12536 PyArrayObject *tmp15 = NULL ;
12537 PyArrayObject *tmp16 = NULL ;
12538 char **tmp17 = NULL ;
12539 int res18 ;
12540 char *buf18 = 0 ;
12541 int alloc18 = 0 ;
12542 int res19 ;
12543 char *buf19 = 0 ;
12544 int alloc19 = 0 ;
12545 int res20 ;
12546 char *buf20 = 0 ;
12547 int alloc20 = 0 ;
12548 PyObject *swig_obj[19] ;
12549
12550 arg1 = &temp1;
12551 if (!SWIG_Python_UnpackTuple(args, "plstripc", 19, 19, swig_obj)) SWIG_fail;
12552 res2 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf2, NULL, &alloc2);
12553 if (!SWIG_IsOK(res2)) {
12554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
12555 }
12556 arg2 = (char *)(buf2);
12557 res3 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf3, NULL, &alloc3);
12558 if (!SWIG_IsOK(res3)) {
12559 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
12560 }
12561 arg3 = (char *)(buf3);
12562 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
12563 if (!SWIG_IsOK(ecode4)) {
12564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
12565 }
12566 arg4 = (PLFLT)(val4);
12567 ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
12568 if (!SWIG_IsOK(ecode5)) {
12569 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
12570 }
12571 arg5 = (PLFLT)(val5);
12572 ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
12573 if (!SWIG_IsOK(ecode6)) {
12574 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
12575 }
12576 arg6 = (PLFLT)(val6);
12577 ecode7 = SWIG_AsVal_double(swig_obj[5], &val7);
12578 if (!SWIG_IsOK(ecode7)) {
12579 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
12580 }
12581 arg7 = (PLFLT)(val7);
12582 ecode8 = SWIG_AsVal_double(swig_obj[6], &val8);
12583 if (!SWIG_IsOK(ecode8)) {
12584 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
12585 }
12586 arg8 = (PLFLT)(val8);
12587 ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
12588 if (!SWIG_IsOK(ecode9)) {
12589 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
12590 }
12591 arg9 = (PLFLT)(val9);
12592 ecode10 = SWIG_AsVal_double(swig_obj[8], &val10);
12593 if (!SWIG_IsOK(ecode10)) {
12594 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
12595 }
12596 arg10 = (PLFLT)(val10);
12597 ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
12598 if (!SWIG_IsOK(ecode11)) {
12599 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
12600 }
12601 arg11 = (PLBOOL)(val11);
12602 ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
12603 if (!SWIG_IsOK(ecode12)) {
12604 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
12605 }
12606 arg12 = (PLBOOL)(val12);
12607 ecode13 = SWIG_AsVal_int(swig_obj[11], &val13);
12608 if (!SWIG_IsOK(ecode13)) {
12609 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
12610 }
12611 arg13 = (PLINT)(val13);
12612 ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
12613 if (!SWIG_IsOK(ecode14)) {
12614 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
12615 }
12616 arg14 = (PLINT)(val14);
12617 {
12618 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
12619 if ( tmp15 == NULL )
12620 return NULL;
12621 Alen = PyArray_DIMS( tmp15 )[0];
12622 arg15 = (PLINT *) PyArray_DATA( tmp15 );
12623 }
12624 {
12625 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[14], NPY_PLINT, 1, 1 );
12626 if ( tmp16 == NULL )
12627 return NULL;
12628 if ( PyArray_DIMS( tmp16 )[0] != Alen )
12629 {
12630 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12631 return NULL;
12632 }
12633 arg16 = (PLINT *) PyArray_DATA( tmp16 );
12634 }
12635 {
12636 int i;
12637 PyObject *elt, *unicode_string;
12638
12639 if ( !PySequence_Check( swig_obj[15] ) || PySequence_Size( swig_obj[15] ) != 4 )
12640 {
12641 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
12642 return NULL;
12643 }
12644 if ( Alen != 4 )
12645 {
12646 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
12647 return NULL;
12648 }
12649 tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
12650 if ( tmp17 == NULL )
12651 return NULL;
12652 arg17 = tmp17;
12653 for ( i = 0; i < 4; i++ )
12654 {
12655 arg17[i] = NULL;
12656 elt = PySequence_Fast_GET_ITEM( swig_obj[15], i );
12657 if ( PyString_Check( elt ) )
12658 {
12659 arg17[i] = PyString_AsString( elt );
12660 }
12661 else if ( PyUnicode_Check( elt ) )
12662 {
12663 unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
12664 arg17[i] = PyBytes_AS_STRING( unicode_string );
12665 }
12666 if ( arg17[i] == NULL )
12667 {
12668 free( tmp17 );
12669 return NULL;
12670 }
12671 }
12672 }
12673 res18 = SWIG_AsCharPtrAndSize(swig_obj[16], &buf18, NULL, &alloc18);
12674 if (!SWIG_IsOK(res18)) {
12675 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
12676 }
12677 arg18 = (char *)(buf18);
12678 res19 = SWIG_AsCharPtrAndSize(swig_obj[17], &buf19, NULL, &alloc19);
12679 if (!SWIG_IsOK(res19)) {
12680 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
12681 }
12682 arg19 = (char *)(buf19);
12683 res20 = SWIG_AsCharPtrAndSize(swig_obj[18], &buf20, NULL, &alloc20);
12684 if (!SWIG_IsOK(res20)) {
12685 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
12686 }
12687 arg20 = (char *)(buf20);
12688 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);
12689 resultobj = SWIG_Py_Void();
12690 if (SWIG_IsTmpObj(res1)) {
12691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
12692 } else {
12693 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
12695 }
12696 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12697 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
12698 {
12699 Py_CLEAR( tmp15 );
12700 }
12701 {
12702 Py_CLEAR( tmp16 );
12703 }
12704 {
12705 free( tmp17 );
12706 }
12707 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
12708 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
12709 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
12710 return resultobj;
12711fail:
12712 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12713 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
12714 {
12715 Py_CLEAR( tmp15 );
12716 }
12717 {
12718 Py_CLEAR( tmp16 );
12719 }
12720 {
12721 free( tmp17 );
12722 }
12723 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
12724 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
12725 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
12726 return NULL;
12727}
12728
12729
12730SWIGINTERN PyObject *_wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12731 PyObject *resultobj = 0;
12732 PLINT arg1 ;
12733 int val1 ;
12734 int ecode1 = 0 ;
12735 PyObject *swig_obj[1] ;
12736
12737 if (!args) SWIG_fail;
12738 swig_obj[0] = args;
12739 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12740 if (!SWIG_IsOK(ecode1)) {
12741 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
12742 }
12743 arg1 = (PLINT)(val1);
12744 plstripd(arg1);
12745 resultobj = SWIG_Py_Void();
12746 return resultobj;
12747fail:
12748 return NULL;
12749}
12750
12751
12752SWIGINTERN PyObject *_wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12753 PyObject *resultobj = 0;
12754 PLINT arg1 ;
12755 PLINT *arg2 = (PLINT *) 0 ;
12756 PLINT *arg3 = (PLINT *) 0 ;
12757 PyArrayObject *tmp1 = NULL ;
12758 PyArrayObject *tmp3 = NULL ;
12759 PyObject *swig_obj[2] ;
12760
12761 if (!SWIG_Python_UnpackTuple(args, "plstyl", 2, 2, swig_obj)) SWIG_fail;
12762 {
12763 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
12764 if ( tmp1 == NULL )
12765 return NULL;
12766 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12767 arg2 = (PLINT *) PyArray_DATA( tmp1 );
12768 }
12769 {
12770 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
12771 if ( tmp3 == NULL )
12772 return NULL;
12773 if ( PyArray_DIMS( tmp3 )[0] != Alen )
12774 {
12775 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12776 return NULL;
12777 }
12778 arg3 = (PLINT *) PyArray_DATA( tmp3 );
12779 }
12780 plstyl(arg1,(int const *)arg2,(int const *)arg3);
12781 resultobj = SWIG_Py_Void();
12782 {
12783 Py_CLEAR( tmp1 );
12784 }
12785 {
12786 Py_CLEAR( tmp3 );
12787 }
12788 return resultobj;
12789fail:
12790 {
12791 Py_CLEAR( tmp1 );
12792 }
12793 {
12794 Py_CLEAR( tmp3 );
12795 }
12796 return NULL;
12797}
12798
12799
12800SWIGINTERN PyObject *_wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12801 PyObject *resultobj = 0;
12802 PLFLT *arg1 = (PLFLT *) 0 ;
12803 PLFLT *arg2 = (PLFLT *) 0 ;
12804 PLINT arg3 ;
12805 PLBOOL arg4 ;
12806 PyArrayObject *tmp1 = NULL ;
12807 PyArrayObject *tmp2 = NULL ;
12808 int val4 ;
12809 int ecode4 = 0 ;
12810 PyObject *swig_obj[3] ;
12811
12812 if (!SWIG_Python_UnpackTuple(args, "plsvect", 3, 3, swig_obj)) SWIG_fail;
12813 {
12814 if ( swig_obj[0] != Py_None )
12815 {
12816 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12817 if ( tmp1 == NULL )
12818 return NULL;
12819 Alen = PyArray_DIMS( tmp1 )[0];
12820 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
12821 }
12822 else
12823 {
12824 arg1 = NULL;
12825 Alen = 0;
12826 }
12827 }
12828 {
12829 if ( swig_obj[1] != Py_None )
12830 {
12831 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12832 if ( tmp2 == NULL )
12833 return NULL;
12834 if ( PyArray_DIMS( tmp2 )[0] != Alen )
12835 {
12836 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12837 return NULL;
12838 }
12839 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
12840 arg3 = PyArray_DIMS( tmp2 )[0];
12841 }
12842 else
12843 {
12844 arg2 = NULL;
12845 arg3 = 0;
12846 }
12847 }
12848 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
12849 if (!SWIG_IsOK(ecode4)) {
12850 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
12851 }
12852 arg4 = (PLBOOL)(val4);
12853 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
12854 resultobj = SWIG_Py_Void();
12855 {
12856 Py_CLEAR( tmp1 );
12857 }
12858 {
12859 Py_CLEAR( tmp2 );
12860 }
12861 return resultobj;
12862fail:
12863 {
12864 Py_CLEAR( tmp1 );
12865 }
12866 {
12867 Py_CLEAR( tmp2 );
12868 }
12869 return NULL;
12870}
12871
12872
12873SWIGINTERN PyObject *_wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12874 PyObject *resultobj = 0;
12875 PLFLT arg1 ;
12876 PLFLT arg2 ;
12877 PLFLT arg3 ;
12878 PLFLT arg4 ;
12879 double val1 ;
12880 int ecode1 = 0 ;
12881 double val2 ;
12882 int ecode2 = 0 ;
12883 double val3 ;
12884 int ecode3 = 0 ;
12885 double val4 ;
12886 int ecode4 = 0 ;
12887 PyObject *swig_obj[4] ;
12888
12889 if (!SWIG_Python_UnpackTuple(args, "plsvpa", 4, 4, swig_obj)) SWIG_fail;
12890 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12891 if (!SWIG_IsOK(ecode1)) {
12892 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
12893 }
12894 arg1 = (PLFLT)(val1);
12895 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12896 if (!SWIG_IsOK(ecode2)) {
12897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
12898 }
12899 arg2 = (PLFLT)(val2);
12900 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
12901 if (!SWIG_IsOK(ecode3)) {
12902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
12903 }
12904 arg3 = (PLFLT)(val3);
12905 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
12906 if (!SWIG_IsOK(ecode4)) {
12907 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
12908 }
12909 arg4 = (PLFLT)(val4);
12910 plsvpa(arg1,arg2,arg3,arg4);
12911 resultobj = SWIG_Py_Void();
12912 return resultobj;
12913fail:
12914 return NULL;
12915}
12916
12917
12918SWIGINTERN PyObject *_wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12919 PyObject *resultobj = 0;
12920 PLINT arg1 ;
12921 PLINT arg2 ;
12922 int val1 ;
12923 int ecode1 = 0 ;
12924 int val2 ;
12925 int ecode2 = 0 ;
12926 PyObject *swig_obj[2] ;
12927
12928 if (!SWIG_Python_UnpackTuple(args, "plsxax", 2, 2, swig_obj)) SWIG_fail;
12929 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12930 if (!SWIG_IsOK(ecode1)) {
12931 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
12932 }
12933 arg1 = (PLINT)(val1);
12934 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12935 if (!SWIG_IsOK(ecode2)) {
12936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
12937 }
12938 arg2 = (PLINT)(val2);
12939 plsxax(arg1,arg2);
12940 resultobj = SWIG_Py_Void();
12941 return resultobj;
12942fail:
12943 return NULL;
12944}
12945
12946
12947SWIGINTERN PyObject *_wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12948 PyObject *resultobj = 0;
12949 PLINT arg1 ;
12950 PLINT arg2 ;
12951 int val1 ;
12952 int ecode1 = 0 ;
12953 int val2 ;
12954 int ecode2 = 0 ;
12955 PyObject *swig_obj[2] ;
12956
12957 if (!SWIG_Python_UnpackTuple(args, "plsyax", 2, 2, swig_obj)) SWIG_fail;
12958 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12959 if (!SWIG_IsOK(ecode1)) {
12960 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
12961 }
12962 arg1 = (PLINT)(val1);
12963 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12964 if (!SWIG_IsOK(ecode2)) {
12965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
12966 }
12967 arg2 = (PLINT)(val2);
12968 plsyax(arg1,arg2);
12969 resultobj = SWIG_Py_Void();
12970 return resultobj;
12971fail:
12972 return NULL;
12973}
12974
12975
12976SWIGINTERN PyObject *_wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12977 PyObject *resultobj = 0;
12978 PLINT arg1 ;
12979 PLFLT *arg2 = (PLFLT *) 0 ;
12980 PLFLT *arg3 = (PLFLT *) 0 ;
12981 PLINT arg4 ;
12982 PyArrayObject *tmp1 = NULL ;
12983 PyArrayObject *tmp3 = NULL ;
12984 int val4 ;
12985 int ecode4 = 0 ;
12986 PyObject *swig_obj[3] ;
12987
12988 if (!SWIG_Python_UnpackTuple(args, "plsym", 3, 3, swig_obj)) SWIG_fail;
12989 {
12990 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12991 if ( tmp1 == NULL )
12992 return NULL;
12993 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12994 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12995 }
12996 {
12997 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12998 if ( tmp3 == NULL )
12999 return NULL;
13000 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13001 {
13002 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13003 return NULL;
13004 }
13005 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13006 }
13007 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13008 if (!SWIG_IsOK(ecode4)) {
13009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13010 }
13011 arg4 = (PLINT)(val4);
13012 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13013 resultobj = SWIG_Py_Void();
13014 {
13015 Py_CLEAR( tmp1 );
13016 }
13017 {
13018 Py_CLEAR( tmp3 );
13019 }
13020 return resultobj;
13021fail:
13022 {
13023 Py_CLEAR( tmp1 );
13024 }
13025 {
13026 Py_CLEAR( tmp3 );
13027 }
13028 return NULL;
13029}
13030
13031
13032SWIGINTERN PyObject *_wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13033 PyObject *resultobj = 0;
13034 PLINT arg1 ;
13035 PLINT arg2 ;
13036 int val1 ;
13037 int ecode1 = 0 ;
13038 int val2 ;
13039 int ecode2 = 0 ;
13040 PyObject *swig_obj[2] ;
13041
13042 if (!SWIG_Python_UnpackTuple(args, "plszax", 2, 2, swig_obj)) SWIG_fail;
13043 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13044 if (!SWIG_IsOK(ecode1)) {
13045 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13046 }
13047 arg1 = (PLINT)(val1);
13048 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13049 if (!SWIG_IsOK(ecode2)) {
13050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13051 }
13052 arg2 = (PLINT)(val2);
13053 plszax(arg1,arg2);
13054 resultobj = SWIG_Py_Void();
13055 return resultobj;
13056fail:
13057 return NULL;
13058}
13059
13060
13061SWIGINTERN PyObject *_wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13062 PyObject *resultobj = 0;
13063
13064 if (!SWIG_Python_UnpackTuple(args, "pltext", 0, 0, 0)) SWIG_fail;
13065 pltext();
13066 resultobj = SWIG_Py_Void();
13067 return resultobj;
13068fail:
13069 return NULL;
13070}
13071
13072
13073SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13074 PyObject *resultobj = 0;
13075 char *arg1 = (char *) 0 ;
13076 int res1 ;
13077 char *buf1 = 0 ;
13078 int alloc1 = 0 ;
13079 PyObject *swig_obj[1] ;
13080
13081 if (!args) SWIG_fail;
13082 swig_obj[0] = args;
13083 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13084 if (!SWIG_IsOK(res1)) {
13085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13086 }
13087 arg1 = (char *)(buf1);
13088 pltimefmt((char const *)arg1);
13089 resultobj = SWIG_Py_Void();
13090 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13091 return resultobj;
13092fail:
13093 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13094 return NULL;
13095}
13096
13097
13098SWIGINTERN PyObject *_wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13099 PyObject *resultobj = 0;
13100 PLFLT arg1 ;
13101 double val1 ;
13102 int ecode1 = 0 ;
13103 PyObject *swig_obj[1] ;
13104
13105 if (!args) SWIG_fail;
13106 swig_obj[0] = args;
13107 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13108 if (!SWIG_IsOK(ecode1)) {
13109 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13110 }
13111 arg1 = (PLFLT)(val1);
13112 plvasp(arg1);
13113 resultobj = SWIG_Py_Void();
13114 return resultobj;
13115fail:
13116 return NULL;
13117}
13118
13119
13120SWIGINTERN PyObject *_wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13121 PyObject *resultobj = 0;
13122 PLFLT **arg1 = (PLFLT **) 0 ;
13123 PLFLT **arg2 = (PLFLT **) 0 ;
13124 PLINT arg3 ;
13125 PLINT arg4 ;
13126 PLFLT arg5 ;
13127 pltr_func arg6 = (pltr_func) 0 ;
13128 PLPointer arg7 = (PLPointer) 0 ;
13129 PyArrayObject *tmp1 = NULL ;
13130 PyArrayObject *tmp2 = NULL ;
13131 double val5 ;
13132 int ecode5 = 0 ;
13133 PyObject *swig_obj[5] ;
13134
13135 {
13136 python_pltr = 0;
13137 arg6 = NULL;
13138 }
13139 {
13140 arg7 = NULL;
13141 }
13142 if (!SWIG_Python_UnpackTuple(args, "plvect", 3, 5, swig_obj)) SWIG_fail;
13143 {
13144 int i, size;
13145 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
13146 if ( tmp1 == NULL )
13147 return NULL;
13148 Xlen = PyArray_DIMS( tmp1 )[0];
13149 Ylen = PyArray_DIMS( tmp1 )[1];
13150 size = Ylen;
13151 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13152 for ( i = 0; i < Xlen; i++ )
13153 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13154 }
13155 {
13156 int i, size;
13157 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 2, 2 );
13158 if ( tmp2 == NULL )
13159 return NULL;
13160 if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13161 {
13162 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13163 return NULL;
13164 }
13165 arg3 = PyArray_DIMS( tmp2 )[0];
13166 arg4 = PyArray_DIMS( tmp2 )[1];
13167 size = arg4;
13168 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13169 for ( i = 0; i < arg3; i++ )
13170 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13171 }
13172 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
13173 if (!SWIG_IsOK(ecode5)) {
13174 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13175 }
13176 arg5 = (PLFLT)(val5);
13177 if (swig_obj[3]) {
13178 {
13179 // it must be a callable or None
13180 if ( swig_obj[3] == Py_None )
13181 {
13182 arg6 = NULL;
13183 }
13184 else
13185 {
13186 if ( !PyCallable_Check( (PyObject *) swig_obj[3] ) )
13187 {
13188 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13189 return NULL;
13190 }
13191 arg6 = marshal_pltr( swig_obj[3] );
13192 }
13193 }
13194 }
13195 if (swig_obj[4]) {
13196 {
13197 if ( swig_obj[4] == Py_None )
13198 arg7 = NULL;
13199 else
13200 {
13201 arg7 = marshal_PLPointer( swig_obj[4], 0 );
13202 }
13203 }
13204 }
13205 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13206 resultobj = SWIG_Py_Void();
13207 {
13208 Py_CLEAR( tmp1 );
13209 free( arg1 );
13210 }
13211 {
13212 Py_CLEAR( tmp2 );
13213 free( arg2 );
13214 }
13215 {
13216 cleanup_pltr();
13217 }
13218 {
13220 }
13221 return resultobj;
13222fail:
13223 {
13224 Py_CLEAR( tmp1 );
13225 free( arg1 );
13226 }
13227 {
13228 Py_CLEAR( tmp2 );
13229 free( arg2 );
13230 }
13231 {
13232 cleanup_pltr();
13233 }
13234 {
13236 }
13237 return NULL;
13238}
13239
13240
13241SWIGINTERN PyObject *_wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13242 PyObject *resultobj = 0;
13243 PLFLT arg1 ;
13244 PLFLT arg2 ;
13245 PLFLT arg3 ;
13246 PLFLT arg4 ;
13247 PLFLT arg5 ;
13248 double val1 ;
13249 int ecode1 = 0 ;
13250 double val2 ;
13251 int ecode2 = 0 ;
13252 double val3 ;
13253 int ecode3 = 0 ;
13254 double val4 ;
13255 int ecode4 = 0 ;
13256 double val5 ;
13257 int ecode5 = 0 ;
13258 PyObject *swig_obj[5] ;
13259
13260 if (!SWIG_Python_UnpackTuple(args, "plvpas", 5, 5, swig_obj)) SWIG_fail;
13261 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13262 if (!SWIG_IsOK(ecode1)) {
13263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13264 }
13265 arg1 = (PLFLT)(val1);
13266 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13267 if (!SWIG_IsOK(ecode2)) {
13268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13269 }
13270 arg2 = (PLFLT)(val2);
13271 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13272 if (!SWIG_IsOK(ecode3)) {
13273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13274 }
13275 arg3 = (PLFLT)(val3);
13276 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13277 if (!SWIG_IsOK(ecode4)) {
13278 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13279 }
13280 arg4 = (PLFLT)(val4);
13281 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13282 if (!SWIG_IsOK(ecode5)) {
13283 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13284 }
13285 arg5 = (PLFLT)(val5);
13286 plvpas(arg1,arg2,arg3,arg4,arg5);
13287 resultobj = SWIG_Py_Void();
13288 return resultobj;
13289fail:
13290 return NULL;
13291}
13292
13293
13294SWIGINTERN PyObject *_wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13295 PyObject *resultobj = 0;
13296 PLFLT arg1 ;
13297 PLFLT arg2 ;
13298 PLFLT arg3 ;
13299 PLFLT arg4 ;
13300 double val1 ;
13301 int ecode1 = 0 ;
13302 double val2 ;
13303 int ecode2 = 0 ;
13304 double val3 ;
13305 int ecode3 = 0 ;
13306 double val4 ;
13307 int ecode4 = 0 ;
13308 PyObject *swig_obj[4] ;
13309
13310 if (!SWIG_Python_UnpackTuple(args, "plvpor", 4, 4, swig_obj)) SWIG_fail;
13311 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13312 if (!SWIG_IsOK(ecode1)) {
13313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13314 }
13315 arg1 = (PLFLT)(val1);
13316 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13317 if (!SWIG_IsOK(ecode2)) {
13318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13319 }
13320 arg2 = (PLFLT)(val2);
13321 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13322 if (!SWIG_IsOK(ecode3)) {
13323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13324 }
13325 arg3 = (PLFLT)(val3);
13326 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13327 if (!SWIG_IsOK(ecode4)) {
13328 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13329 }
13330 arg4 = (PLFLT)(val4);
13331 plvpor(arg1,arg2,arg3,arg4);
13332 resultobj = SWIG_Py_Void();
13333 return resultobj;
13334fail:
13335 return NULL;
13336}
13337
13338
13339SWIGINTERN PyObject *_wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13340 PyObject *resultobj = 0;
13341
13342 if (!SWIG_Python_UnpackTuple(args, "plvsta", 0, 0, 0)) SWIG_fail;
13343 plvsta();
13344 resultobj = SWIG_Py_Void();
13345 return resultobj;
13346fail:
13347 return NULL;
13348}
13349
13350
13351SWIGINTERN PyObject *_wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13352 PyObject *resultobj = 0;
13353 PLFLT arg1 ;
13354 PLFLT arg2 ;
13355 PLFLT arg3 ;
13356 PLFLT arg4 ;
13357 PLFLT arg5 ;
13358 PLFLT arg6 ;
13359 PLFLT arg7 ;
13360 PLFLT arg8 ;
13361 PLFLT arg9 ;
13362 PLFLT arg10 ;
13363 PLFLT arg11 ;
13364 double val1 ;
13365 int ecode1 = 0 ;
13366 double val2 ;
13367 int ecode2 = 0 ;
13368 double val3 ;
13369 int ecode3 = 0 ;
13370 double val4 ;
13371 int ecode4 = 0 ;
13372 double val5 ;
13373 int ecode5 = 0 ;
13374 double val6 ;
13375 int ecode6 = 0 ;
13376 double val7 ;
13377 int ecode7 = 0 ;
13378 double val8 ;
13379 int ecode8 = 0 ;
13380 double val9 ;
13381 int ecode9 = 0 ;
13382 double val10 ;
13383 int ecode10 = 0 ;
13384 double val11 ;
13385 int ecode11 = 0 ;
13386 PyObject *swig_obj[11] ;
13387
13388 if (!SWIG_Python_UnpackTuple(args, "plw3d", 11, 11, swig_obj)) SWIG_fail;
13389 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13390 if (!SWIG_IsOK(ecode1)) {
13391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13392 }
13393 arg1 = (PLFLT)(val1);
13394 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13395 if (!SWIG_IsOK(ecode2)) {
13396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13397 }
13398 arg2 = (PLFLT)(val2);
13399 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13400 if (!SWIG_IsOK(ecode3)) {
13401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13402 }
13403 arg3 = (PLFLT)(val3);
13404 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13405 if (!SWIG_IsOK(ecode4)) {
13406 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13407 }
13408 arg4 = (PLFLT)(val4);
13409 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13410 if (!SWIG_IsOK(ecode5)) {
13411 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13412 }
13413 arg5 = (PLFLT)(val5);
13414 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13415 if (!SWIG_IsOK(ecode6)) {
13416 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13417 }
13418 arg6 = (PLFLT)(val6);
13419 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13420 if (!SWIG_IsOK(ecode7)) {
13421 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13422 }
13423 arg7 = (PLFLT)(val7);
13424 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
13425 if (!SWIG_IsOK(ecode8)) {
13426 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13427 }
13428 arg8 = (PLFLT)(val8);
13429 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
13430 if (!SWIG_IsOK(ecode9)) {
13431 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13432 }
13433 arg9 = (PLFLT)(val9);
13434 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
13435 if (!SWIG_IsOK(ecode10)) {
13436 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13437 }
13438 arg10 = (PLFLT)(val10);
13439 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
13440 if (!SWIG_IsOK(ecode11)) {
13441 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13442 }
13443 arg11 = (PLFLT)(val11);
13444 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13445 resultobj = SWIG_Py_Void();
13446 return resultobj;
13447fail:
13448 return NULL;
13449}
13450
13451
13452SWIGINTERN PyObject *_wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13453 PyObject *resultobj = 0;
13454 PLFLT arg1 ;
13455 double val1 ;
13456 int ecode1 = 0 ;
13457 PyObject *swig_obj[1] ;
13458
13459 if (!args) SWIG_fail;
13460 swig_obj[0] = args;
13461 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13462 if (!SWIG_IsOK(ecode1)) {
13463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
13464 }
13465 arg1 = (PLFLT)(val1);
13466 plwidth(arg1);
13467 resultobj = SWIG_Py_Void();
13468 return resultobj;
13469fail:
13470 return NULL;
13471}
13472
13473
13474SWIGINTERN PyObject *_wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13475 PyObject *resultobj = 0;
13476 PLFLT arg1 ;
13477 PLFLT arg2 ;
13478 PLFLT arg3 ;
13479 PLFLT arg4 ;
13480 double val1 ;
13481 int ecode1 = 0 ;
13482 double val2 ;
13483 int ecode2 = 0 ;
13484 double val3 ;
13485 int ecode3 = 0 ;
13486 double val4 ;
13487 int ecode4 = 0 ;
13488 PyObject *swig_obj[4] ;
13489
13490 if (!SWIG_Python_UnpackTuple(args, "plwind", 4, 4, swig_obj)) SWIG_fail;
13491 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13492 if (!SWIG_IsOK(ecode1)) {
13493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
13494 }
13495 arg1 = (PLFLT)(val1);
13496 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13497 if (!SWIG_IsOK(ecode2)) {
13498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
13499 }
13500 arg2 = (PLFLT)(val2);
13501 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13502 if (!SWIG_IsOK(ecode3)) {
13503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
13504 }
13505 arg3 = (PLFLT)(val3);
13506 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13507 if (!SWIG_IsOK(ecode4)) {
13508 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
13509 }
13510 arg4 = (PLFLT)(val4);
13511 plwind(arg1,arg2,arg3,arg4);
13512 resultobj = SWIG_Py_Void();
13513 return resultobj;
13514fail:
13515 return NULL;
13516}
13517
13518
13519SWIGINTERN PyObject *_wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13520 PyObject *resultobj = 0;
13521 PLBOOL arg1 ;
13522 PLBOOL *arg2 = (PLBOOL *) 0 ;
13523 int val1 ;
13524 int ecode1 = 0 ;
13525 PLBOOL temp2 ;
13526 int res2 = SWIG_TMPOBJ ;
13527 PyObject *swig_obj[1] ;
13528
13529 arg2 = &temp2;
13530 if (!args) SWIG_fail;
13531 swig_obj[0] = args;
13532 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13533 if (!SWIG_IsOK(ecode1)) {
13534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
13535 }
13536 arg1 = (PLBOOL)(val1);
13537 plxormod(arg1,arg2);
13538 resultobj = SWIG_Py_Void();
13539 if (SWIG_IsTmpObj(res2)) {
13540 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13541 } else {
13542 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13543 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13544 }
13545 return resultobj;
13546fail:
13547 return NULL;
13548}
13549
13550
13551SWIGINTERN PyObject *_wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13552 PyObject *resultobj = 0;
13553 mapform_func arg1 = (mapform_func) 0 ;
13554 char *arg2 = (char *) 0 ;
13555 PLFLT arg3 ;
13556 PLFLT arg4 ;
13557 PLFLT arg5 ;
13558 PLFLT arg6 ;
13559 int res2 ;
13560 char *buf2 = 0 ;
13561 int alloc2 = 0 ;
13562 double val3 ;
13563 int ecode3 = 0 ;
13564 double val4 ;
13565 int ecode4 = 0 ;
13566 double val5 ;
13567 int ecode5 = 0 ;
13568 double val6 ;
13569 int ecode6 = 0 ;
13570 PyObject *swig_obj[6] ;
13571
13572 if (!SWIG_Python_UnpackTuple(args, "plmap", 6, 6, swig_obj)) SWIG_fail;
13573 {
13574 // it must be a callable or none
13575 if ( swig_obj[0] == Py_None )
13576 {
13577 arg1 = NULL;
13578 }
13579 else
13580 {
13581 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13582 {
13583 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13584 return NULL;
13585 }
13586 arg1 = marshal_mapform( swig_obj[0] );
13587 }
13588 }
13589 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13590 if (!SWIG_IsOK(res2)) {
13591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
13592 }
13593 arg2 = (char *)(buf2);
13594 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13595 if (!SWIG_IsOK(ecode3)) {
13596 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
13597 }
13598 arg3 = (PLFLT)(val3);
13599 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13600 if (!SWIG_IsOK(ecode4)) {
13601 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
13602 }
13603 arg4 = (PLFLT)(val4);
13604 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13605 if (!SWIG_IsOK(ecode5)) {
13606 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
13607 }
13608 arg5 = (PLFLT)(val5);
13609 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13610 if (!SWIG_IsOK(ecode6)) {
13611 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
13612 }
13613 arg6 = (PLFLT)(val6);
13614 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
13615 resultobj = SWIG_Py_Void();
13616 {
13618 }
13619 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13620 return resultobj;
13621fail:
13622 {
13624 }
13625 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13626 return NULL;
13627}
13628
13629
13630SWIGINTERN PyObject *_wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13631 PyObject *resultobj = 0;
13632 mapform_func arg1 = (mapform_func) 0 ;
13633 char *arg2 = (char *) 0 ;
13634 PLFLT arg3 ;
13635 PLFLT arg4 ;
13636 PLFLT arg5 ;
13637 PLFLT arg6 ;
13638 PLINT *arg7 = (PLINT *) 0 ;
13639 PLINT arg8 ;
13640 int res2 ;
13641 char *buf2 = 0 ;
13642 int alloc2 = 0 ;
13643 double val3 ;
13644 int ecode3 = 0 ;
13645 double val4 ;
13646 int ecode4 = 0 ;
13647 double val5 ;
13648 int ecode5 = 0 ;
13649 double val6 ;
13650 int ecode6 = 0 ;
13651 PyArrayObject *tmp7 = NULL ;
13652 PyObject *swig_obj[7] ;
13653
13654 if (!SWIG_Python_UnpackTuple(args, "plmapline", 7, 7, swig_obj)) SWIG_fail;
13655 {
13656 // it must be a callable or none
13657 if ( swig_obj[0] == Py_None )
13658 {
13659 arg1 = NULL;
13660 }
13661 else
13662 {
13663 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13664 {
13665 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13666 return NULL;
13667 }
13668 arg1 = marshal_mapform( swig_obj[0] );
13669 }
13670 }
13671 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13672 if (!SWIG_IsOK(res2)) {
13673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
13674 }
13675 arg2 = (char *)(buf2);
13676 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13677 if (!SWIG_IsOK(ecode3)) {
13678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
13679 }
13680 arg3 = (PLFLT)(val3);
13681 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13682 if (!SWIG_IsOK(ecode4)) {
13683 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
13684 }
13685 arg4 = (PLFLT)(val4);
13686 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13687 if (!SWIG_IsOK(ecode5)) {
13688 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
13689 }
13690 arg5 = (PLFLT)(val5);
13691 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13692 if (!SWIG_IsOK(ecode6)) {
13693 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
13694 }
13695 arg6 = (PLFLT)(val6);
13696 {
13697 if ( swig_obj[6] != Py_None )
13698 {
13699 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
13700 if ( tmp7 == NULL )
13701 return NULL;
13702 arg7 = (PLINT *) PyArray_DATA( tmp7 );
13703 arg8 = PyArray_DIMS( tmp7 )[0];
13704 }
13705 else
13706 {
13707 arg7 = NULL;
13708 arg8 = 0;
13709 }
13710 }
13711 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
13712 resultobj = SWIG_Py_Void();
13713 {
13715 }
13716 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13717 {
13718 Py_CLEAR( tmp7 );
13719 }
13720 return resultobj;
13721fail:
13722 {
13724 }
13725 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13726 {
13727 Py_CLEAR( tmp7 );
13728 }
13729 return NULL;
13730}
13731
13732
13733SWIGINTERN PyObject *_wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13734 PyObject *resultobj = 0;
13735 mapform_func arg1 = (mapform_func) 0 ;
13736 char *arg2 = (char *) 0 ;
13737 char *arg3 = (char *) 0 ;
13738 PLFLT arg4 ;
13739 PLFLT arg5 ;
13740 PLFLT arg6 ;
13741 PLFLT arg7 ;
13742 PLINT *arg8 = (PLINT *) 0 ;
13743 PLINT arg9 ;
13744 int res2 ;
13745 char *buf2 = 0 ;
13746 int alloc2 = 0 ;
13747 int res3 ;
13748 char *buf3 = 0 ;
13749 int alloc3 = 0 ;
13750 double val4 ;
13751 int ecode4 = 0 ;
13752 double val5 ;
13753 int ecode5 = 0 ;
13754 double val6 ;
13755 int ecode6 = 0 ;
13756 double val7 ;
13757 int ecode7 = 0 ;
13758 PyArrayObject *tmp8 = NULL ;
13759 PyObject *swig_obj[8] ;
13760
13761 if (!SWIG_Python_UnpackTuple(args, "plmapstring", 8, 8, swig_obj)) SWIG_fail;
13762 {
13763 // it must be a callable or none
13764 if ( swig_obj[0] == Py_None )
13765 {
13766 arg1 = NULL;
13767 }
13768 else
13769 {
13770 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13771 {
13772 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13773 return NULL;
13774 }
13775 arg1 = marshal_mapform( swig_obj[0] );
13776 }
13777 }
13778 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13779 if (!SWIG_IsOK(res2)) {
13780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
13781 }
13782 arg2 = (char *)(buf2);
13783 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
13784 if (!SWIG_IsOK(res3)) {
13785 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
13786 }
13787 arg3 = (char *)(buf3);
13788 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13789 if (!SWIG_IsOK(ecode4)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
13791 }
13792 arg4 = (PLFLT)(val4);
13793 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13794 if (!SWIG_IsOK(ecode5)) {
13795 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
13796 }
13797 arg5 = (PLFLT)(val5);
13798 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13799 if (!SWIG_IsOK(ecode6)) {
13800 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
13801 }
13802 arg6 = (PLFLT)(val6);
13803 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13804 if (!SWIG_IsOK(ecode7)) {
13805 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
13806 }
13807 arg7 = (PLFLT)(val7);
13808 {
13809 if ( swig_obj[7] != Py_None )
13810 {
13811 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
13812 if ( tmp8 == NULL )
13813 return NULL;
13814 arg8 = (PLINT *) PyArray_DATA( tmp8 );
13815 arg9 = PyArray_DIMS( tmp8 )[0];
13816 }
13817 else
13818 {
13819 arg8 = NULL;
13820 arg9 = 0;
13821 }
13822 }
13823 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
13824 resultobj = SWIG_Py_Void();
13825 {
13827 }
13828 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13829 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13830 {
13831 Py_CLEAR( tmp8 );
13832 }
13833 return resultobj;
13834fail:
13835 {
13837 }
13838 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13839 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13840 {
13841 Py_CLEAR( tmp8 );
13842 }
13843 return NULL;
13844}
13845
13846
13847SWIGINTERN PyObject *_wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13848 PyObject *resultobj = 0;
13849 mapform_func arg1 = (mapform_func) 0 ;
13850 char *arg2 = (char *) 0 ;
13851 PLFLT arg3 ;
13852 PLFLT arg4 ;
13853 PLFLT arg5 ;
13854 char *arg6 = (char *) 0 ;
13855 PLFLT arg7 ;
13856 PLFLT arg8 ;
13857 PLFLT arg9 ;
13858 PLFLT arg10 ;
13859 PLINT arg11 ;
13860 int res2 ;
13861 char *buf2 = 0 ;
13862 int alloc2 = 0 ;
13863 double val3 ;
13864 int ecode3 = 0 ;
13865 double val4 ;
13866 int ecode4 = 0 ;
13867 double val5 ;
13868 int ecode5 = 0 ;
13869 int res6 ;
13870 char *buf6 = 0 ;
13871 int alloc6 = 0 ;
13872 double val7 ;
13873 int ecode7 = 0 ;
13874 double val8 ;
13875 int ecode8 = 0 ;
13876 double val9 ;
13877 int ecode9 = 0 ;
13878 double val10 ;
13879 int ecode10 = 0 ;
13880 int val11 ;
13881 int ecode11 = 0 ;
13882 PyObject *swig_obj[11] ;
13883
13884 if (!SWIG_Python_UnpackTuple(args, "plmaptex", 11, 11, swig_obj)) SWIG_fail;
13885 {
13886 // it must be a callable or none
13887 if ( swig_obj[0] == Py_None )
13888 {
13889 arg1 = NULL;
13890 }
13891 else
13892 {
13893 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13894 {
13895 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13896 return NULL;
13897 }
13898 arg1 = marshal_mapform( swig_obj[0] );
13899 }
13900 }
13901 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13902 if (!SWIG_IsOK(res2)) {
13903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
13904 }
13905 arg2 = (char *)(buf2);
13906 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13907 if (!SWIG_IsOK(ecode3)) {
13908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
13909 }
13910 arg3 = (PLFLT)(val3);
13911 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13912 if (!SWIG_IsOK(ecode4)) {
13913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
13914 }
13915 arg4 = (PLFLT)(val4);
13916 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13917 if (!SWIG_IsOK(ecode5)) {
13918 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
13919 }
13920 arg5 = (PLFLT)(val5);
13921 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
13922 if (!SWIG_IsOK(res6)) {
13923 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
13924 }
13925 arg6 = (char *)(buf6);
13926 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13927 if (!SWIG_IsOK(ecode7)) {
13928 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
13929 }
13930 arg7 = (PLFLT)(val7);
13931 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
13932 if (!SWIG_IsOK(ecode8)) {
13933 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
13934 }
13935 arg8 = (PLFLT)(val8);
13936 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
13937 if (!SWIG_IsOK(ecode9)) {
13938 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
13939 }
13940 arg9 = (PLFLT)(val9);
13941 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
13942 if (!SWIG_IsOK(ecode10)) {
13943 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
13944 }
13945 arg10 = (PLFLT)(val10);
13946 ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
13947 if (!SWIG_IsOK(ecode11)) {
13948 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
13949 }
13950 arg11 = (PLINT)(val11);
13951 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
13952 resultobj = SWIG_Py_Void();
13953 {
13955 }
13956 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13957 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
13958 return resultobj;
13959fail:
13960 {
13962 }
13963 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13964 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
13965 return NULL;
13966}
13967
13968
13969SWIGINTERN PyObject *_wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13970 PyObject *resultobj = 0;
13971 mapform_func arg1 = (mapform_func) 0 ;
13972 char *arg2 = (char *) 0 ;
13973 PLFLT arg3 ;
13974 PLFLT arg4 ;
13975 PLFLT arg5 ;
13976 PLFLT arg6 ;
13977 PLINT *arg7 = (PLINT *) 0 ;
13978 PLINT arg8 ;
13979 int res2 ;
13980 char *buf2 = 0 ;
13981 int alloc2 = 0 ;
13982 double val3 ;
13983 int ecode3 = 0 ;
13984 double val4 ;
13985 int ecode4 = 0 ;
13986 double val5 ;
13987 int ecode5 = 0 ;
13988 double val6 ;
13989 int ecode6 = 0 ;
13990 PyArrayObject *tmp7 = NULL ;
13991 PyObject *swig_obj[7] ;
13992
13993 if (!SWIG_Python_UnpackTuple(args, "plmapfill", 7, 7, swig_obj)) SWIG_fail;
13994 {
13995 // it must be a callable or none
13996 if ( swig_obj[0] == Py_None )
13997 {
13998 arg1 = NULL;
13999 }
14000 else
14001 {
14002 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14003 {
14004 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14005 return NULL;
14006 }
14007 arg1 = marshal_mapform( swig_obj[0] );
14008 }
14009 }
14010 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14011 if (!SWIG_IsOK(res2)) {
14012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14013 }
14014 arg2 = (char *)(buf2);
14015 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14016 if (!SWIG_IsOK(ecode3)) {
14017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14018 }
14019 arg3 = (PLFLT)(val3);
14020 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14021 if (!SWIG_IsOK(ecode4)) {
14022 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14023 }
14024 arg4 = (PLFLT)(val4);
14025 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14026 if (!SWIG_IsOK(ecode5)) {
14027 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14028 }
14029 arg5 = (PLFLT)(val5);
14030 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14031 if (!SWIG_IsOK(ecode6)) {
14032 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14033 }
14034 arg6 = (PLFLT)(val6);
14035 {
14036 if ( swig_obj[6] != Py_None )
14037 {
14038 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14039 if ( tmp7 == NULL )
14040 return NULL;
14041 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14042 arg8 = PyArray_DIMS( tmp7 )[0];
14043 }
14044 else
14045 {
14046 arg7 = NULL;
14047 arg8 = 0;
14048 }
14049 }
14050 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14051 resultobj = SWIG_Py_Void();
14052 {
14054 }
14055 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14056 {
14057 Py_CLEAR( tmp7 );
14058 }
14059 return resultobj;
14060fail:
14061 {
14063 }
14064 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14065 {
14066 Py_CLEAR( tmp7 );
14067 }
14068 return NULL;
14069}
14070
14071
14072SWIGINTERN PyObject *_wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14073 PyObject *resultobj = 0;
14074 mapform_func arg1 = (mapform_func) 0 ;
14075 PLFLT arg2 ;
14076 PLFLT arg3 ;
14077 PLFLT arg4 ;
14078 PLFLT arg5 ;
14079 PLFLT arg6 ;
14080 PLFLT arg7 ;
14081 double val2 ;
14082 int ecode2 = 0 ;
14083 double val3 ;
14084 int ecode3 = 0 ;
14085 double val4 ;
14086 int ecode4 = 0 ;
14087 double val5 ;
14088 int ecode5 = 0 ;
14089 double val6 ;
14090 int ecode6 = 0 ;
14091 double val7 ;
14092 int ecode7 = 0 ;
14093 PyObject *swig_obj[7] ;
14094
14095 if (!SWIG_Python_UnpackTuple(args, "plmeridians", 7, 7, swig_obj)) SWIG_fail;
14096 {
14097 // it must be a callable or none
14098 if ( swig_obj[0] == Py_None )
14099 {
14100 arg1 = NULL;
14101 }
14102 else
14103 {
14104 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14105 {
14106 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14107 return NULL;
14108 }
14109 arg1 = marshal_mapform( swig_obj[0] );
14110 }
14111 }
14112 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14113 if (!SWIG_IsOK(ecode2)) {
14114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14115 }
14116 arg2 = (PLFLT)(val2);
14117 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14118 if (!SWIG_IsOK(ecode3)) {
14119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14120 }
14121 arg3 = (PLFLT)(val3);
14122 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14123 if (!SWIG_IsOK(ecode4)) {
14124 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14125 }
14126 arg4 = (PLFLT)(val4);
14127 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14128 if (!SWIG_IsOK(ecode5)) {
14129 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14130 }
14131 arg5 = (PLFLT)(val5);
14132 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14133 if (!SWIG_IsOK(ecode6)) {
14134 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14135 }
14136 arg6 = (PLFLT)(val6);
14137 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14138 if (!SWIG_IsOK(ecode7)) {
14139 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14140 }
14141 arg7 = (PLFLT)(val7);
14142 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14143 resultobj = SWIG_Py_Void();
14144 {
14146 }
14147 return resultobj;
14148fail:
14149 {
14151 }
14152 return NULL;
14153}
14154
14155
14156SWIGINTERN PyObject *_wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14157 PyObject *resultobj = 0;
14158 PLFLT **arg1 = (PLFLT **) 0 ;
14159 PLINT arg2 ;
14160 PLINT arg3 ;
14161 PLFLT arg4 ;
14162 PLFLT arg5 ;
14163 PLFLT arg6 ;
14164 PLFLT arg7 ;
14165 PLFLT arg8 ;
14166 PLFLT arg9 ;
14167 PLFLT arg10 ;
14168 PLFLT arg11 ;
14169 PLFLT arg12 ;
14170 PLFLT arg13 ;
14171 PyArrayObject *tmp1 = NULL ;
14172 double val4 ;
14173 int ecode4 = 0 ;
14174 double val5 ;
14175 int ecode5 = 0 ;
14176 double val6 ;
14177 int ecode6 = 0 ;
14178 double val7 ;
14179 int ecode7 = 0 ;
14180 double val8 ;
14181 int ecode8 = 0 ;
14182 double val9 ;
14183 int ecode9 = 0 ;
14184 double val10 ;
14185 int ecode10 = 0 ;
14186 double val11 ;
14187 int ecode11 = 0 ;
14188 double val12 ;
14189 int ecode12 = 0 ;
14190 double val13 ;
14191 int ecode13 = 0 ;
14192 PyObject *swig_obj[11] ;
14193
14194 if (!SWIG_Python_UnpackTuple(args, "plimage", 11, 11, swig_obj)) SWIG_fail;
14195 {
14196 int i, size;
14197 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14198 if ( tmp1 == NULL )
14199 return NULL;
14200 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14201 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14202 size = arg3;
14203 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14204 for ( i = 0; i < arg2; i++ )
14205 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14206 }
14207 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14208 if (!SWIG_IsOK(ecode4)) {
14209 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14210 }
14211 arg4 = (PLFLT)(val4);
14212 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14213 if (!SWIG_IsOK(ecode5)) {
14214 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14215 }
14216 arg5 = (PLFLT)(val5);
14217 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14218 if (!SWIG_IsOK(ecode6)) {
14219 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14220 }
14221 arg6 = (PLFLT)(val6);
14222 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14223 if (!SWIG_IsOK(ecode7)) {
14224 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14225 }
14226 arg7 = (PLFLT)(val7);
14227 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14228 if (!SWIG_IsOK(ecode8)) {
14229 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14230 }
14231 arg8 = (PLFLT)(val8);
14232 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14233 if (!SWIG_IsOK(ecode9)) {
14234 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14235 }
14236 arg9 = (PLFLT)(val9);
14237 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14238 if (!SWIG_IsOK(ecode10)) {
14239 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14240 }
14241 arg10 = (PLFLT)(val10);
14242 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14243 if (!SWIG_IsOK(ecode11)) {
14244 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14245 }
14246 arg11 = (PLFLT)(val11);
14247 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
14248 if (!SWIG_IsOK(ecode12)) {
14249 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14250 }
14251 arg12 = (PLFLT)(val12);
14252 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
14253 if (!SWIG_IsOK(ecode13)) {
14254 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14255 }
14256 arg13 = (PLFLT)(val13);
14257 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14258 resultobj = SWIG_Py_Void();
14259 {
14260 Py_CLEAR( tmp1 );
14261 free( arg1 );
14262 }
14263 return resultobj;
14264fail:
14265 {
14266 Py_CLEAR( tmp1 );
14267 free( arg1 );
14268 }
14269 return NULL;
14270}
14271
14272
14273SWIGINTERN PyObject *_wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14274 PyObject *resultobj = 0;
14275 PLFLT **arg1 = (PLFLT **) 0 ;
14276 PLINT arg2 ;
14277 PLINT arg3 ;
14278 PLFLT arg4 ;
14279 PLFLT arg5 ;
14280 PLFLT arg6 ;
14281 PLFLT arg7 ;
14282 PLFLT arg8 ;
14283 PLFLT arg9 ;
14284 PLFLT arg10 ;
14285 PLFLT arg11 ;
14286 pltr_func arg12 = (pltr_func) 0 ;
14287 PLPointer arg13 = (PLPointer) 0 ;
14288 PyArrayObject *tmp1 = NULL ;
14289 double val4 ;
14290 int ecode4 = 0 ;
14291 double val5 ;
14292 int ecode5 = 0 ;
14293 double val6 ;
14294 int ecode6 = 0 ;
14295 double val7 ;
14296 int ecode7 = 0 ;
14297 double val8 ;
14298 int ecode8 = 0 ;
14299 double val9 ;
14300 int ecode9 = 0 ;
14301 double val10 ;
14302 int ecode10 = 0 ;
14303 double val11 ;
14304 int ecode11 = 0 ;
14305 PyObject *swig_obj[11] ;
14306
14307 {
14308 python_pltr = 0;
14309 arg12 = NULL;
14310 }
14311 {
14312 arg13 = NULL;
14313 }
14314 if (!SWIG_Python_UnpackTuple(args, "plimagefr", 9, 11, swig_obj)) SWIG_fail;
14315 {
14316 int i, size;
14317 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14318 if ( tmp1 == NULL )
14319 return NULL;
14320 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14321 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14322 size = arg3;
14323 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14324 for ( i = 0; i < arg2; i++ )
14325 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14326 }
14327 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14328 if (!SWIG_IsOK(ecode4)) {
14329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14330 }
14331 arg4 = (PLFLT)(val4);
14332 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14333 if (!SWIG_IsOK(ecode5)) {
14334 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14335 }
14336 arg5 = (PLFLT)(val5);
14337 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14338 if (!SWIG_IsOK(ecode6)) {
14339 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14340 }
14341 arg6 = (PLFLT)(val6);
14342 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14343 if (!SWIG_IsOK(ecode7)) {
14344 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14345 }
14346 arg7 = (PLFLT)(val7);
14347 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14348 if (!SWIG_IsOK(ecode8)) {
14349 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14350 }
14351 arg8 = (PLFLT)(val8);
14352 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14353 if (!SWIG_IsOK(ecode9)) {
14354 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14355 }
14356 arg9 = (PLFLT)(val9);
14357 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14358 if (!SWIG_IsOK(ecode10)) {
14359 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14360 }
14361 arg10 = (PLFLT)(val10);
14362 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14363 if (!SWIG_IsOK(ecode11)) {
14364 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14365 }
14366 arg11 = (PLFLT)(val11);
14367 if (swig_obj[9]) {
14368 {
14369 // it must be a callable or None
14370 if ( swig_obj[9] == Py_None )
14371 {
14372 arg12 = NULL;
14373 }
14374 else
14375 {
14376 if ( !PyCallable_Check( (PyObject *) swig_obj[9] ) )
14377 {
14378 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
14379 return NULL;
14380 }
14381 arg12 = marshal_pltr( swig_obj[9] );
14382 }
14383 }
14384 }
14385 if (swig_obj[10]) {
14386 {
14387 if ( swig_obj[10] == Py_None )
14388 arg13 = NULL;
14389 else
14390 {
14391 arg13 = marshal_PLPointer( swig_obj[10], 1 );
14392 }
14393 }
14394 }
14395 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14396 resultobj = SWIG_Py_Void();
14397 {
14398 Py_CLEAR( tmp1 );
14399 free( arg1 );
14400 }
14401 {
14402 cleanup_pltr();
14403 }
14404 {
14406 }
14407 return resultobj;
14408fail:
14409 {
14410 Py_CLEAR( tmp1 );
14411 free( arg1 );
14412 }
14413 {
14414 cleanup_pltr();
14415 }
14416 {
14418 }
14419 return NULL;
14420}
14421
14422
14423SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14424 PyObject *resultobj = 0;
14425
14426 if (!SWIG_Python_UnpackTuple(args, "plClearOpts", 0, 0, 0)) SWIG_fail;
14427 plClearOpts();
14428 resultobj = SWIG_Py_Void();
14429 return resultobj;
14430fail:
14431 return NULL;
14432}
14433
14434
14435SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14436 PyObject *resultobj = 0;
14437
14438 if (!SWIG_Python_UnpackTuple(args, "plResetOpts", 0, 0, 0)) SWIG_fail;
14439 plResetOpts();
14440 resultobj = SWIG_Py_Void();
14441 return resultobj;
14442fail:
14443 return NULL;
14444}
14445
14446
14447SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14448 PyObject *resultobj = 0;
14449 char *arg1 = (char *) 0 ;
14450 char *arg2 = (char *) 0 ;
14451 int res1 ;
14452 char *buf1 = 0 ;
14453 int alloc1 = 0 ;
14454 int res2 ;
14455 char *buf2 = 0 ;
14456 int alloc2 = 0 ;
14457 PyObject *swig_obj[2] ;
14458
14459 if (!SWIG_Python_UnpackTuple(args, "plSetUsage", 2, 2, swig_obj)) SWIG_fail;
14460 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
14461 if (!SWIG_IsOK(res1)) {
14462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
14463 }
14464 arg1 = (char *)(buf1);
14465 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14466 if (!SWIG_IsOK(res2)) {
14467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
14468 }
14469 arg2 = (char *)(buf2);
14470 plSetUsage((char const *)arg1,(char const *)arg2);
14471 resultobj = SWIG_Py_Void();
14472 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14473 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14474 return resultobj;
14475fail:
14476 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14477 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14478 return NULL;
14479}
14480
14481
14482SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14483 PyObject *resultobj = 0;
14484
14485 if (!SWIG_Python_UnpackTuple(args, "plOptUsage", 0, 0, 0)) SWIG_fail;
14486 plOptUsage();
14487 resultobj = SWIG_Py_Void();
14488 return resultobj;
14489fail:
14490 return NULL;
14491}
14492
14493
14494SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14495 PyObject *resultobj = 0;
14496 PLFLT **arg1 = (PLFLT **) 0 ;
14497 PLINT arg2 ;
14498 PLINT arg3 ;
14499 PLFLT *arg4 = (PLFLT *) 0 ;
14500 PLFLT *arg5 = (PLFLT *) 0 ;
14501 PyArrayObject *tmp1 = NULL ;
14502 PLFLT temp4 ;
14503 int res4 = SWIG_TMPOBJ ;
14504 PLFLT temp5 ;
14505 int res5 = SWIG_TMPOBJ ;
14506 PyObject *swig_obj[1] ;
14507
14508 arg4 = &temp4;
14509 arg5 = &temp5;
14510 if (!args) SWIG_fail;
14511 swig_obj[0] = args;
14512 {
14513 int i, size;
14514 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14515 if ( tmp1 == NULL )
14516 return NULL;
14517 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14518 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14519 size = arg3;
14520 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14521 for ( i = 0; i < arg2; i++ )
14522 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14523 }
14524 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
14525 resultobj = SWIG_Py_Void();
14526 if (SWIG_IsTmpObj(res4)) {
14527 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
14528 } else {
14529 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14530 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14531 }
14532 if (SWIG_IsTmpObj(res5)) {
14533 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
14534 } else {
14535 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
14537 }
14538 {
14539 Py_CLEAR( tmp1 );
14540 free( arg1 );
14541 }
14542 return resultobj;
14543fail:
14544 {
14545 Py_CLEAR( tmp1 );
14546 free( arg1 );
14547 }
14548 return NULL;
14549}
14550
14551
14552SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14553 PyObject *resultobj = 0;
14554 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14555 void *argp1 = 0 ;
14556 int res1 = 0 ;
14557 PyObject *swig_obj[1] ;
14558 PLINT result;
14559
14560 if (!args) SWIG_fail;
14561 swig_obj[0] = args;
14562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14563 if (!SWIG_IsOK(res1)) {
14564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14565 }
14566 arg1 = (PLGraphicsIn *)(argp1);
14567 result = (PLINT)plGetCursor(arg1);
14568 resultobj = SWIG_From_int((int)(result));
14569 return resultobj;
14570fail:
14571 return NULL;
14572}
14573
14574
14575static PyMethodDef SwigMethods[] = {
14576 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
14577 { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
14578 { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
14579 { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
14580 { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
14581 { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_O, NULL},
14582 { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
14583 { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_O, NULL},
14584 { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
14585 { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_O, NULL},
14586 { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
14587 { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_O, NULL},
14588 { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
14589 { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_O, NULL},
14590 { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
14591 { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_O, NULL},
14592 { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
14593 { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_O, NULL},
14594 { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
14595 { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_O, NULL},
14596 { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
14597 { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_O, NULL},
14598 { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
14599 { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_O, NULL},
14600 { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
14601 { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_O, NULL},
14602 { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
14603 { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_O, NULL},
14604 { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_NOARGS, NULL},
14605 { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_O, NULL},
14606 { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_O, NULL},
14607 { "PLGraphicsIn_swiginit", PLGraphicsIn_swiginit, METH_VARARGS, NULL},
14608 { "plsxwin", _wrap_plsxwin, METH_O, NULL},
14609 { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, "\n"
14610 "Set format of numerical label for contours\n"
14611 "\n"
14612 "DESCRIPTION:\n"
14613 "\n"
14614 " Set format of numerical label for contours.\n"
14615 "\n"
14616 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14617 "\n"
14618 " This function is used example 9.\n"
14619 "\n"
14620 "\n"
14621 "\n"
14622 "SYNOPSIS:\n"
14623 "\n"
14624 "pl_setcontlabelformat(lexp, sigdig)\n"
14625 "\n"
14626 "ARGUMENTS:\n"
14627 "\n"
14628 " lexp (PLINT, input) : If the contour numerical label is greater\n"
14629 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14630 " format is used. Default value of lexp is 4.\n"
14631 "\n"
14632 " sigdig (PLINT, input) : Number of significant digits. Default\n"
14633 " value is 2.\n"
14634 "\n"
14635 ""},
14636 { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, "\n"
14637 "Set parameters of contour labelling other than format of numerical label\n"
14638 "\n"
14639 "DESCRIPTION:\n"
14640 "\n"
14641 " Set parameters of contour labelling other than those handled by\n"
14642 " pl_setcontlabelformat.\n"
14643 "\n"
14644 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14645 "\n"
14646 " This function is used in example 9.\n"
14647 "\n"
14648 "\n"
14649 "\n"
14650 "SYNOPSIS:\n"
14651 "\n"
14652 "pl_setcontlabelparam(offset, size, spacing, active)\n"
14653 "\n"
14654 "ARGUMENTS:\n"
14655 "\n"
14656 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
14657 " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
14658 "\n"
14659 " size (PLFLT, input) : Font height for contour labels (normalized).\n"
14660 " Default value is 0.3.\n"
14661 "\n"
14662 " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
14663 " Default value is 0.1.\n"
14664 "\n"
14665 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
14666 " contour labels on. Default is off (0).\n"
14667 "\n"
14668 ""},
14669 { "pladv", _wrap_pladv, METH_O, "\n"
14670 "Advance the (sub-)page\n"
14671 "\n"
14672 "DESCRIPTION:\n"
14673 "\n"
14674 " Advances to the next subpage if sub=0, performing a page advance if\n"
14675 " there are no remaining subpages on the current page. If subpages\n"
14676 " aren't being used, pladv(0) will always advance the page. If page>0,\n"
14677 " PLplot switches to the specified subpage. Note that this allows you\n"
14678 " to overwrite a plot on the specified subpage; if this is not what you\n"
14679 " intended, use pleop followed by plbop to first advance the page. This\n"
14680 " routine is called automatically (with page=0) by plenv, but if plenv\n"
14681 " is not used, pladv must be called after initializing PLplot but before\n"
14682 " defining the viewport.\n"
14683 "\n"
14684 " Redacted form: pladv(page)\n"
14685 "\n"
14686 " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
14687 " 29, and 31.\n"
14688 "\n"
14689 "\n"
14690 "\n"
14691 "SYNOPSIS:\n"
14692 "\n"
14693 "pladv(page)\n"
14694 "\n"
14695 "ARGUMENTS:\n"
14696 "\n"
14697 " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
14698 " in the top left corner and increasing along the rows) to which to\n"
14699 " advance. Set to zero to advance to the next subpage (or to the\n"
14700 " next page if subpages are not being used).\n"
14701 "\n"
14702 ""},
14703 { "plarc", _wrap_plarc, METH_VARARGS, "\n"
14704 "Draw a circular or elliptical arc\n"
14705 "\n"
14706 "DESCRIPTION:\n"
14707 "\n"
14708 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
14709 " semiminor axis b, starting at angle1 and ending at angle2.\n"
14710 "\n"
14711 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
14712 " fill)\n"
14713 "\n"
14714 "\n"
14715 " This function is used in examples 3 and 27.\n"
14716 "\n"
14717 "\n"
14718 "\n"
14719 "SYNOPSIS:\n"
14720 "\n"
14721 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
14722 "\n"
14723 "ARGUMENTS:\n"
14724 "\n"
14725 " x (PLFLT, input) : X coordinate of arc center.\n"
14726 "\n"
14727 " y (PLFLT, input) : Y coordinate of arc center.\n"
14728 "\n"
14729 " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
14730 "\n"
14731 " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
14732 "\n"
14733 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
14734 " semimajor axis.\n"
14735 "\n"
14736 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
14737 " semimajor axis.\n"
14738 "\n"
14739 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
14740 " X-axis.\n"
14741 "\n"
14742 " fill (PLBOOL, input) : Draw a filled arc.\n"
14743 "\n"
14744 ""},
14745 { "plaxes", _wrap_plaxes, METH_VARARGS, "\n"
14746 "Draw a box with axes, etc. with arbitrary origin\n"
14747 "\n"
14748 "DESCRIPTION:\n"
14749 "\n"
14750 " Draws a box around the currently defined viewport with arbitrary\n"
14751 " world-coordinate origin specified by x0 and y0 and labels it with\n"
14752 " world coordinate values appropriate to the window. Thus plaxes should\n"
14753 " only be called after defining both viewport and window. The ascii\n"
14754 " character strings xopt and yopt specify how the box should be drawn as\n"
14755 " described below. If ticks and/or subticks are to be drawn for a\n"
14756 " particular axis, the tick intervals and number of subintervals may be\n"
14757 " specified explicitly, or they may be defaulted by setting the\n"
14758 " appropriate arguments to zero.\n"
14759 "\n"
14760 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
14761 " ytick, nysub)\n"
14762 "\n"
14763 "\n"
14764 " This function is not used in any examples.\n"
14765 "\n"
14766 "\n"
14767 "\n"
14768 "SYNOPSIS:\n"
14769 "\n"
14770 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14771 "\n"
14772 "ARGUMENTS:\n"
14773 "\n"
14774 " x0 (PLFLT, input) : World X coordinate of origin.\n"
14775 "\n"
14776 " y0 (PLFLT, input) : World Y coordinate of origin.\n"
14777 "\n"
14778 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
14779 " options for the x axis. The string can include any combination of\n"
14780 " the following letters (upper or lower case) in any order: a: Draws\n"
14781 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
14782 " (x=0).\n"
14783 " b: Draws bottom (X) or left (Y) edge of frame.\n"
14784 " c: Draws top (X) or right (Y) edge of frame.\n"
14785 " d: Plot labels as date / time. Values are assumed to be\n"
14786 " seconds since the epoch (as used by gmtime).\n"
14787 " f: Always use fixed point numeric labels.\n"
14788 " g: Draws a grid at the major tick interval.\n"
14789 " h: Draws a grid at the minor tick interval.\n"
14790 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
14791 " inwards.\n"
14792 " l: Labels axis logarithmically. This only affects the labels,\n"
14793 " not the data, and so it is necessary to compute the logarithms\n"
14794 " of data points before passing them to any of the drawing\n"
14795 " routines.\n"
14796 " m: Writes numeric labels at major tick intervals in the\n"
14797 " unconventional location (above box for X, right of box for Y).\n"
14798 " n: Writes numeric labels at major tick intervals in the\n"
14799 " conventional location (below box for X, left of box for Y).\n"
14800 " o: Use custom labelling function to generate axis label text.\n"
14801 " The custom labelling function can be defined with the\n"
14802 " plslabelfunc command.\n"
14803 " s: Enables subticks between major ticks, only valid if t is\n"
14804 " also specified.\n"
14805 " t: Draws major ticks.\n"
14806 " u: Exactly like \"b\" except don't draw edge line.\n"
14807 " w: Exactly like \"c\" except don't draw edge line.\n"
14808 " x: Exactly like \"t\" (including the side effect of the\n"
14809 " numerical labels for the major ticks) except exclude drawing\n"
14810 " the major and minor tick marks.\n"
14811 "\n"
14812 "\n"
14813 " xtick (PLFLT, input) : World coordinate interval between major\n"
14814 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
14815 " generates a suitable tick interval.\n"
14816 "\n"
14817 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
14818 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14819 " generates a suitable minor tick interval.\n"
14820 "\n"
14821 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
14822 " options for the y axis. The string can include any combination of\n"
14823 " the letters defined above for xopt, and in addition may contain:\n"
14824 " v: Write numeric labels for the y axis parallel to the base of the\n"
14825 " graph, rather than parallel to the axis.\n"
14826 "\n"
14827 "\n"
14828 " ytick (PLFLT, input) : World coordinate interval between major\n"
14829 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
14830 " generates a suitable tick interval.\n"
14831 "\n"
14832 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
14833 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
14834 " generates a suitable minor tick interval.\n"
14835 "\n"
14836 ""},
14837 { "plbin", _wrap_plbin, METH_VARARGS, "\n"
14838 "Plot a histogram from binned data\n"
14839 "\n"
14840 "DESCRIPTION:\n"
14841 "\n"
14842 " Plots a histogram consisting of nbin bins. The value associated with\n"
14843 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
14844 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
14845 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
14846 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
14847 " placed midway between the values in the x vector. Also see plhist for\n"
14848 " drawing histograms from unbinned data.\n"
14849 "\n"
14850 " Redacted form: General: plbin(x, y, opt)\n"
14851 " Python: plbin(nbin, x, y, opt)\n"
14852 "\n"
14853 "\n"
14854 " This function is not used in any examples.\n"
14855 "\n"
14856 "\n"
14857 "\n"
14858 "SYNOPSIS:\n"
14859 "\n"
14860 "plbin(nbin, x, y, opt)\n"
14861 "\n"
14862 "ARGUMENTS:\n"
14863 "\n"
14864 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
14865 " and y vectors.)\n"
14866 "\n"
14867 " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
14868 " with bins. These must form a strictly increasing sequence.\n"
14869 "\n"
14870 " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
14871 " proportional to the number of points in each bin. This is a PLFLT\n"
14872 " (instead of PLINT) vector so as to allow histograms of\n"
14873 " probabilities, etc.\n"
14874 "\n"
14875 " opt (PLINT, input) : Is a combination of several flags:\n"
14876 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
14877 " outer bins are expanded to fill up the entire x-axis and bins of\n"
14878 " zero height are simply drawn.\n"
14879 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
14880 " between the x values. If the values in x are equally spaced,\n"
14881 " the values are the center values of the bins.\n"
14882 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
14883 " size as the ones inside.\n"
14884 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
14885 " (there is a gap for such bins).\n"
14886 "\n"
14887 ""},
14888 { "plbtime", _wrap_plbtime, METH_O, "\n"
14889 "Calculate broken-down time from continuous time for the current stream\n"
14890 "\n"
14891 "DESCRIPTION:\n"
14892 "\n"
14893 " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
14894 " continuous time, ctime for the current stream. This function is the\n"
14895 " inverse of plctime.\n"
14896 "\n"
14897 " The PLplot definition of broken-down time is a calendar time that\n"
14898 " completely ignores all time zone offsets, i.e., it is the user's\n"
14899 " responsibility to apply those offsets (if so desired) before using the\n"
14900 " PLplot time API. By default broken-down time is defined using the\n"
14901 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
14902 " continuous time is defined as the number of seconds since the Unix\n"
14903 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
14904 " broken-down and continuous time are possible, see plconfigtime.\n"
14905 "\n"
14906 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
14907 " ctime)\n"
14908 "\n"
14909 "\n"
14910 " This function is used in example 29.\n"
14911 "\n"
14912 "\n"
14913 "\n"
14914 "SYNOPSIS:\n"
14915 "\n"
14916 "plbtime(year, month, day, hour, min, sec, ctime)\n"
14917 "\n"
14918 "ARGUMENTS:\n"
14919 "\n"
14920 " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
14921 " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
14922 " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
14923 " BCE, etc.)\n"
14924 "\n"
14925 " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
14926 " the year in the range from 0 (January) to 11 (December).\n"
14927 "\n"
14928 " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
14929 " month in the range from 1 to 31.\n"
14930 "\n"
14931 " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
14932 " day in the range from 0 to 23.\n"
14933 "\n"
14934 " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
14935 " hour in the range from 0 to 59\n"
14936 "\n"
14937 " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
14938 " minute in range from 0. to 60.\n"
14939 "\n"
14940 " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
14941 " time is calculated.\n"
14942 "\n"
14943 ""},
14944 { "plbop", _wrap_plbop, METH_NOARGS, "\n"
14945 "Begin a new page\n"
14946 "\n"
14947 "DESCRIPTION:\n"
14948 "\n"
14949 " Begins a new page. For a file driver, the output file is opened if\n"
14950 " necessary. Advancing the page via pleop and plbop is useful when a\n"
14951 " page break is desired at a particular point when plotting to subpages.\n"
14952 " Another use for pleop and plbop is when plotting pages to different\n"
14953 " files, since you can manually set the file name by calling plsfnam\n"
14954 " after the call to pleop. (In fact some drivers may only support a\n"
14955 " single page per file, making this a necessity.) One way to handle\n"
14956 " this case automatically is to page advance via pladv, but enable\n"
14957 " familying (see plsfam) with a small limit on the file size so that a\n"
14958 " new family member file will be created on each page break.\n"
14959 "\n"
14960 " Redacted form: plbop()\n"
14961 "\n"
14962 " This function is used in examples 2 and 20.\n"
14963 "\n"
14964 "\n"
14965 "\n"
14966 "SYNOPSIS:\n"
14967 "\n"
14968 "plbop()\n"
14969 "\n"
14970 ""},
14971 { "plbox", _wrap_plbox, METH_VARARGS, "\n"
14972 "Draw a box with axes, etc\n"
14973 "\n"
14974 "DESCRIPTION:\n"
14975 "\n"
14976 " Draws a box around the currently defined viewport, and labels it with\n"
14977 " world coordinate values appropriate to the window. Thus plbox should\n"
14978 " only be called after defining both viewport and window. The ascii\n"
14979 " character strings xopt and yopt specify how the box should be drawn as\n"
14980 " described below. If ticks and/or subticks are to be drawn for a\n"
14981 " particular axis, the tick intervals and number of subintervals may be\n"
14982 " specified explicitly, or they may be defaulted by setting the\n"
14983 " appropriate arguments to zero.\n"
14984 "\n"
14985 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14986 "\n"
14987 "\n"
14988 " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
14989 " and 29.\n"
14990 "\n"
14991 "\n"
14992 "\n"
14993 "SYNOPSIS:\n"
14994 "\n"
14995 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
14996 "\n"
14997 "ARGUMENTS:\n"
14998 "\n"
14999 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15000 " options for the x axis. The string can include any combination of\n"
15001 " the following letters (upper or lower case) in any order: a: Draws\n"
15002 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15003 " (x=0).\n"
15004 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15005 " c: Draws top (X) or right (Y) edge of frame.\n"
15006 " d: Plot labels as date / time. Values are assumed to be\n"
15007 " seconds since the epoch (as used by gmtime).\n"
15008 " f: Always use fixed point numeric labels.\n"
15009 " g: Draws a grid at the major tick interval.\n"
15010 " h: Draws a grid at the minor tick interval.\n"
15011 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15012 " inwards.\n"
15013 " l: Labels axis logarithmically. This only affects the labels,\n"
15014 " not the data, and so it is necessary to compute the logarithms\n"
15015 " of data points before passing them to any of the drawing\n"
15016 " routines.\n"
15017 " m: Writes numeric labels at major tick intervals in the\n"
15018 " unconventional location (above box for X, right of box for Y).\n"
15019 " n: Writes numeric labels at major tick intervals in the\n"
15020 " conventional location (below box for X, left of box for Y).\n"
15021 " o: Use custom labelling function to generate axis label text.\n"
15022 " The custom labelling function can be defined with the\n"
15023 " plslabelfunc command.\n"
15024 " s: Enables subticks between major ticks, only valid if t is\n"
15025 " also specified.\n"
15026 " t: Draws major ticks.\n"
15027 " u: Exactly like \"b\" except don't draw edge line.\n"
15028 " w: Exactly like \"c\" except don't draw edge line.\n"
15029 " x: Exactly like \"t\" (including the side effect of the\n"
15030 " numerical labels for the major ticks) except exclude drawing\n"
15031 " the major and minor tick marks.\n"
15032 "\n"
15033 "\n"
15034 " xtick (PLFLT, input) : World coordinate interval between major\n"
15035 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15036 " generates a suitable tick interval.\n"
15037 "\n"
15038 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15039 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15040 " generates a suitable minor tick interval.\n"
15041 "\n"
15042 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15043 " options for the y axis. The string can include any combination of\n"
15044 " the letters defined above for xopt, and in addition may contain:\n"
15045 " v: Write numeric labels for the y axis parallel to the base of the\n"
15046 " graph, rather than parallel to the axis.\n"
15047 "\n"
15048 "\n"
15049 " ytick (PLFLT, input) : World coordinate interval between major\n"
15050 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15051 " generates a suitable tick interval.\n"
15052 "\n"
15053 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15054 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15055 " generates a suitable minor tick interval.\n"
15056 "\n"
15057 ""},
15058 { "plbox3", _wrap_plbox3, METH_VARARGS, "\n"
15059 "Draw a box with axes, etc, in 3-d\n"
15060 "\n"
15061 "DESCRIPTION:\n"
15062 "\n"
15063 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15064 " plot. For a more complete description of three-dimensional plotting\n"
15065 " see the PLplot documentation.\n"
15066 "\n"
15067 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15068 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15069 "\n"
15070 "\n"
15071 " This function is used in examples 8, 11, 18, and 21.\n"
15072 "\n"
15073 "\n"
15074 "\n"
15075 "SYNOPSIS:\n"
15076 "\n"
15077 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15078 "\n"
15079 "ARGUMENTS:\n"
15080 "\n"
15081 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15082 " options for the x axis. The string can include any combination of\n"
15083 " the following letters (upper or lower case) in any order: b: Draws\n"
15084 " axis at base, at height z=\n"
15085 " zmin where zmin is defined by call to plw3d. This character must be\n"
15086 " specified in order to use any of the other options.\n"
15087 " d: Plot labels as date / time. Values are assumed to be\n"
15088 " seconds since the epoch (as used by gmtime).\n"
15089 " f: Always use fixed point numeric labels.\n"
15090 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15091 " than upwards.\n"
15092 " l: Labels axis logarithmically. This only affects the labels,\n"
15093 " not the data, and so it is necessary to compute the logarithms\n"
15094 " of data points before passing them to any of the drawing\n"
15095 " routines.\n"
15096 " n: Writes numeric labels at major tick intervals.\n"
15097 " o: Use custom labelling function to generate axis label text.\n"
15098 " The custom labelling function can be defined with the\n"
15099 " plslabelfunc command.\n"
15100 " s: Enables subticks between major ticks, only valid if t is\n"
15101 " also specified.\n"
15102 " t: Draws major ticks.\n"
15103 " u: If this is specified, the text label for the axis is\n"
15104 " written under the axis.\n"
15105 "\n"
15106 "\n"
15107 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15108 " the text label for the x axis. It is only drawn if u is in the\n"
15109 " xopt string.\n"
15110 "\n"
15111 " xtick (PLFLT, input) : World coordinate interval between major\n"
15112 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15113 " generates a suitable tick interval.\n"
15114 "\n"
15115 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15116 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15117 " generates a suitable minor tick interval.\n"
15118 "\n"
15119 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15120 " options for the y axis. The string is interpreted in the same way\n"
15121 " as xopt.\n"
15122 "\n"
15123 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15124 " the text label for the y axis. It is only drawn if u is in the\n"
15125 " yopt string.\n"
15126 "\n"
15127 " ytick (PLFLT, input) : World coordinate interval between major\n"
15128 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15129 " generates a suitable tick interval.\n"
15130 "\n"
15131 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15132 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15133 " generates a suitable minor tick interval.\n"
15134 "\n"
15135 " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15136 " options for the z axis. The string can include any combination of\n"
15137 " the following letters (upper or lower case) in any order: b: Draws\n"
15138 " z axis to the left of the surface plot.\n"
15139 " c: Draws z axis to the right of the surface plot.\n"
15140 " d: Draws grid lines parallel to the x-y plane behind the\n"
15141 " figure. These lines are not drawn until after plot3d or\n"
15142 " plmesh are called because of the need for hidden line removal.\n"
15143 " e: Plot labels as date / time. Values are assumed to be\n"
15144 " seconds since the epoch (as used by gmtime). Note this\n"
15145 " suboption is interpreted the same as the d suboption for xopt\n"
15146 " and yopt, but it has to be identified as e for zopt since d\n"
15147 " has already been used for the different purpose above.\n"
15148 " f: Always use fixed point numeric labels.\n"
15149 " i: Inverts tick marks, so they are drawn away from the center.\n"
15150 " l: Labels axis logarithmically. This only affects the labels,\n"
15151 " not the data, and so it is necessary to compute the logarithms\n"
15152 " of data points before passing them to any of the drawing\n"
15153 " routines.\n"
15154 " m: Writes numeric labels at major tick intervals on the\n"
15155 " right-hand z axis.\n"
15156 " n: Writes numeric labels at major tick intervals on the\n"
15157 " left-hand z axis.\n"
15158 " o: Use custom labelling function to generate axis label text.\n"
15159 " The custom labelling function can be defined with the\n"
15160 " plslabelfunc command.\n"
15161 " s: Enables subticks between major ticks, only valid if t is\n"
15162 " also specified.\n"
15163 " t: Draws major ticks.\n"
15164 " u: If this is specified, the text label is written beside the\n"
15165 " left-hand axis.\n"
15166 " v: If this is specified, the text label is written beside the\n"
15167 " right-hand axis.\n"
15168 "\n"
15169 "\n"
15170 " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15171 " the text label for the z axis. It is only drawn if u or v are in\n"
15172 " the zopt string.\n"
15173 "\n"
15174 " ztick (PLFLT, input) : World coordinate interval between major\n"
15175 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15176 " generates a suitable tick interval.\n"
15177 "\n"
15178 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15179 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15180 " generates a suitable minor tick interval.\n"
15181 "\n"
15182 ""},
15183 { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, "\n"
15184 "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15185 "\n"
15186 "DESCRIPTION:\n"
15187 "\n"
15188 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15189 " from relative device coordinates, rx and ry.\n"
15190 "\n"
15191 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15192 "\n"
15193 "\n"
15194 " This function is used in example 31.\n"
15195 "\n"
15196 "\n"
15197 "\n"
15198 "SYNOPSIS:\n"
15199 "\n"
15200 "plcalc_world(rx, ry, wx, wy, window)\n"
15201 "\n"
15202 "ARGUMENTS:\n"
15203 "\n"
15204 " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15205 " the x coordinate.\n"
15206 "\n"
15207 " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15208 " the y coordinate.\n"
15209 "\n"
15210 " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15211 " coordinate corresponding to the relative device coordinates rx and\n"
15212 " ry.\n"
15213 "\n"
15214 " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15215 " coordinate corresponding to the relative device coordinates rx and\n"
15216 " ry.\n"
15217 "\n"
15218 " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15219 " defined window index that corresponds to the input relative device\n"
15220 " coordinates (and the returned world coordinates). To give some\n"
15221 " background on the window index, for each page the initial window\n"
15222 " index is set to zero, and each time plwind is called within the\n"
15223 " page, world and device coordinates are stored for the window and\n"
15224 " the window index is incremented. Thus, for a simple page layout\n"
15225 " with non-overlapping viewports and one window per viewport, window\n"
15226 " corresponds to the viewport index (in the order which the\n"
15227 " viewport/windows were created) of the only viewport/window\n"
15228 " corresponding to rx and ry. However, for more complicated layouts\n"
15229 " with potentially overlapping viewports and possibly more than one\n"
15230 " window (set of world coordinates) per viewport, window and the\n"
15231 " corresponding output world coordinates corresponds to the last\n"
15232 " window created that fulfills the criterion that the relative\n"
15233 " device coordinates are inside it. Finally, in all cases where the\n"
15234 " input relative device coordinates are not inside any\n"
15235 " viewport/window, then the returned value of the last defined\n"
15236 " window index is set to -1.\n"
15237 "\n"
15238 ""},
15239 { "plclear", _wrap_plclear, METH_NOARGS, "\n"
15240 "Clear current (sub)page\n"
15241 "\n"
15242 "DESCRIPTION:\n"
15243 "\n"
15244 " Clears the current page, effectively erasing everything that have been\n"
15245 " drawn. This command only works with interactive drivers; if the\n"
15246 " driver does not support this, the page is filled with the background\n"
15247 " color in use. If the current page is divided into subpages, only the\n"
15248 " current subpage is erased. The nth subpage can be selected with\n"
15249 " pladv(n).\n"
15250 "\n"
15251 " Redacted form: General: plclear()\n"
15252 "\n"
15253 "\n"
15254 " This function is not used in any examples.\n"
15255 "\n"
15256 "\n"
15257 "\n"
15258 "SYNOPSIS:\n"
15259 "\n"
15260 "plclear()\n"
15261 "\n"
15262 ""},
15263 { "plcol0", _wrap_plcol0, METH_O, "\n"
15264 "Set color, cmap0\n"
15265 "\n"
15266 "DESCRIPTION:\n"
15267 "\n"
15268 " Sets the color index for cmap0 (see the PLplot documentation).\n"
15269 "\n"
15270 " Redacted form: plcol0(icol0)\n"
15271 "\n"
15272 " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
15273 "\n"
15274 "\n"
15275 "\n"
15276 "SYNOPSIS:\n"
15277 "\n"
15278 "plcol0(icol0)\n"
15279 "\n"
15280 "ARGUMENTS:\n"
15281 "\n"
15282 " icol0 (PLINT, input) : Integer representing the color. The\n"
15283 " defaults at present are (these may change):\n"
15284 " 0 black (default background)\n"
15285 " 1 red (default foreground)\n"
15286 " 2 yellow\n"
15287 " 3 green\n"
15288 " 4 aquamarine\n"
15289 " 5 pink\n"
15290 " 6 wheat\n"
15291 " 7 grey\n"
15292 " 8 brown\n"
15293 " 9 blue\n"
15294 " 10 BlueViolet\n"
15295 " 11 cyan\n"
15296 " 12 turquoise\n"
15297 " 13 magenta\n"
15298 " 14 salmon\n"
15299 " 15 white\n"
15300 "\n"
15301 " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
15302 " change an individual color in the cmap0 color palette.\n"
15303 "\n"
15304 ""},
15305 { "plcol1", _wrap_plcol1, METH_O, "\n"
15306 "Set color, cmap1\n"
15307 "\n"
15308 "DESCRIPTION:\n"
15309 "\n"
15310 " Sets the color for cmap1 (see the PLplot documentation).\n"
15311 "\n"
15312 " Redacted form: plcol1(col1)\n"
15313 "\n"
15314 " This function is used in examples 12 and 21.\n"
15315 "\n"
15316 "\n"
15317 "\n"
15318 "SYNOPSIS:\n"
15319 "\n"
15320 "plcol1(col1)\n"
15321 "\n"
15322 "ARGUMENTS:\n"
15323 "\n"
15324 " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
15325 " is mapped to color using the continuous cmap1 palette which by\n"
15326 " default ranges from blue to the background color to red. The\n"
15327 " cmap1 palette can also be straightforwardly changed by the user\n"
15328 " with plscmap1 or plscmap1l.\n"
15329 "\n"
15330 ""},
15331 { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, "\n"
15332 "Configure the transformation between continuous and broken-down time for the current stream\n"
15333 "\n"
15334 "DESCRIPTION:\n"
15335 "\n"
15336 " Configure the transformation between continuous and broken-down time\n"
15337 " for the current stream. This transformation is used by both plbtime\n"
15338 " and plctime.\n"
15339 "\n"
15340 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
15341 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15342 "\n"
15343 "\n"
15344 " This function is used in example 29.\n"
15345 "\n"
15346 "\n"
15347 "\n"
15348 "SYNOPSIS:\n"
15349 "\n"
15350 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15351 "\n"
15352 "ARGUMENTS:\n"
15353 "\n"
15354 " scale (PLFLT, input) : The number of days per continuous time unit.\n"
15355 " As a special case, if\n"
15356 " scale is 0., then all other arguments are ignored, and the result (the\n"
15357 " default used by PLplot) is the equivalent of a call to\n"
15358 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
15359 " That is, for this special case broken-down time is calculated with\n"
15360 " the proleptic Gregorian calendar with no leap seconds inserted,\n"
15361 " and the continuous time is defined as the number of seconds since\n"
15362 " the Unix epoch of 1970-01-01T00:00:00Z.\n"
15363 "\n"
15364 " offset1 (PLFLT, input) : If\n"
15365 " ifbtime_offset is true, the parameters\n"
15366 " offset1 and\n"
15367 " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
15368 " (with units in days) specify the epoch of the continuous time\n"
15369 " relative to the MJD epoch corresponding to the Gregorian calendar\n"
15370 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
15371 " are used to specify the origin to allow users (by specifying\n"
15372 " offset1 as an integer that can be exactly represented by a\n"
15373 " floating-point variable and specifying\n"
15374 " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
15375 " the numerical errors of the continuous time representation.\n"
15376 "\n"
15377 " offset2 (PLFLT, input) : See documentation of\n"
15378 " offset1.\n"
15379 "\n"
15380 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
15381 " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
15382 " calendar is used for broken-down time rather than the proleptic\n"
15383 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
15384 " have been historically used to define UTC are inserted into the\n"
15385 " broken-down time. Other possibilities for additional control bits\n"
15386 " for ccontrol exist such as making the historical time corrections\n"
15387 " in the broken-down time corresponding to ET (ephemeris time) or\n"
15388 " making the (slightly non-constant) corrections from international\n"
15389 " atomic time (TAI) to what astronomers define as terrestrial time\n"
15390 " (TT). But those additional possibilities have not been\n"
15391 " implemented yet in the qsastime library (one of the PLplot utility\n"
15392 " libraries).\n"
15393 "\n"
15394 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
15395 " epoch of the continuous time scale is specified by the user. If\n"
15396 " ifbtime_offset is false, then\n"
15397 " offset1 and\n"
15398 " offset2 are used to specify the epoch, and the following broken-down\n"
15399 " time parameters are completely ignored. If\n"
15400 " ifbtime_offset is true, then\n"
15401 " offset1 and\n"
15402 " offset2 are completely ignored, and the following broken-down time\n"
15403 " parameters are used to specify the epoch.\n"
15404 "\n"
15405 " year (PLINT, input) : Year of epoch.\n"
15406 "\n"
15407 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
15408 " 11 (December).\n"
15409 "\n"
15410 " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
15411 "\n"
15412 " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
15413 "\n"
15414 " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
15415 "\n"
15416 " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
15417 "\n"
15418 ""},
15419 { "plcont", _wrap_plcont, METH_VARARGS, "\n"
15420 "Contour plot\n"
15421 "\n"
15422 "DESCRIPTION:\n"
15423 "\n"
15424 " Draws a contour plot of the data in f[\n"
15425 " nx][\n"
15426 " ny], using the nlevel contour levels specified by clevel. Only the\n"
15427 " region of the matrix from kx to lx and from ky to ly is plotted out\n"
15428 " where all these index ranges are interpreted as one-based for\n"
15429 " historical reasons. A transformation routine pointed to by pltr with\n"
15430 " a generic pointer pltr_data for additional data required by the\n"
15431 " transformation routine is used to map indices within the matrix to the\n"
15432 " world coordinates.\n"
15433 "\n"
15434 " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
15435 " where (see above discussion) the pltr, pltr_data callback arguments\n"
15436 " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
15437 " vectors; or xg and yg matrices.\n"
15438 "\n"
15439 " This function is used in examples 9, 14, 16, and 22.\n"
15440 "\n"
15441 "\n"
15442 "\n"
15443 "SYNOPSIS:\n"
15444 "\n"
15445 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
15446 "\n"
15447 "ARGUMENTS:\n"
15448 "\n"
15449 " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
15450 "\n"
15451 " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
15452 "\n"
15453 " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
15454 " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
15455 " zero-based for historical backwards-compatibility reasons.\n"
15456 "\n"
15457 " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
15458 " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
15459 " zero-based for historical backwards-compatibility reasons.\n"
15460 "\n"
15461 " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
15462 " which to draw contours.\n"
15463 "\n"
15464 " nlevel (PLINT, input) : Number of contour levels to draw.\n"
15465 "\n"
15466 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
15467 " defines the transformation between the zero-based indices of the\n"
15468 " matrix f and the world coordinates.For the C case, transformation\n"
15469 " functions are provided in the PLplot library: pltr0 for the\n"
15470 " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
15471 " respectively defined by vectors and matrices. In addition, C\n"
15472 " callback routines for the transformation can be supplied by the\n"
15473 " user such as the mypltr function in examples/c/x09c.c which\n"
15474 " provides a general linear transformation between index coordinates\n"
15475 " and world coordinates.For languages other than C you should\n"
15476 " consult the PLplot documentation for the details concerning how\n"
15477 " PLTRANSFORM_callback arguments are interfaced. However, in\n"
15478 " general, a particular pattern of callback-associated arguments\n"
15479 " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
15480 " yg matrices are respectively interfaced to a linear-transformation\n"
15481 " routine similar to the above mypltr function; pltr1; and pltr2.\n"
15482 " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
15483 " the PLplot documentation) support native language callbacks for\n"
15484 " handling index to world-coordinate transformations. Examples of\n"
15485 " these various approaches are given in examples/<language>x09*,\n"
15486 " examples/<language>x16*, examples/<language>x20*,\n"
15487 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
15488 " supported languages.\n"
15489 "\n"
15490 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
15491 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
15492 " that is externally supplied.\n"
15493 "\n"
15494 ""},
15495 { "plctime", _wrap_plctime, METH_VARARGS, "\n"
15496 "Calculate continuous time from broken-down time for the current stream\n"
15497 "\n"
15498 "DESCRIPTION:\n"
15499 "\n"
15500 " Calculate continuous time, ctime, from broken-down time for the\n"
15501 " current stream. The broken-down\n"
15502 " time is specified by the following parameters: year, month, day, hour,\n"
15503 " min, and sec. This function is the inverse of plbtime.\n"
15504 "\n"
15505 " The PLplot definition of broken-down time is a calendar time that\n"
15506 " completely ignores all time zone offsets, i.e., it is the user's\n"
15507 " responsibility to apply those offsets (if so desired) before using the\n"
15508 " PLplot time API. By default broken-down time is defined using the\n"
15509 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15510 " continuous time is defined as the number of seconds since the Unix\n"
15511 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15512 " broken-down and continuous time are possible, see plconfigtime which\n"
15513 " specifies that transformation for the current stream.\n"
15514 "\n"
15515 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
15516 " ctime)\n"
15517 "\n"
15518 "\n"
15519 " This function is used in example 29.\n"
15520 "\n"
15521 "\n"
15522 "\n"
15523 "SYNOPSIS:\n"
15524 "\n"
15525 "plctime(year, month, day, hour, min, sec, ctime)\n"
15526 "\n"
15527 "ARGUMENTS:\n"
15528 "\n"
15529 " year (PLINT, input) : Input year.\n"
15530 "\n"
15531 " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
15532 " (December).\n"
15533 "\n"
15534 " day (PLINT, input) : Input day in range from 1 to 31.\n"
15535 "\n"
15536 " hour (PLINT, input) : Input hour in range from 0 to 23\n"
15537 "\n"
15538 " min (PLINT, input) : Input minute in range from 0 to 59.\n"
15539 "\n"
15540 " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
15541 "\n"
15542 " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
15543 " time calculated from the broken-down time specified by the\n"
15544 " previous parameters.\n"
15545 "\n"
15546 ""},
15547 { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, "\n"
15548 "Copy state parameters from the reference stream to the current stream\n"
15549 "\n"
15550 "DESCRIPTION:\n"
15551 "\n"
15552 " Copies state parameters from the reference stream to the current\n"
15553 " stream. Tell driver interface to map device coordinates unless flags\n"
15554 " == 1.\n"
15555 "\n"
15556 " This function is used for making save files of selected plots (e.g.\n"
15557 " from the TK driver). After initializing, you can get a copy of the\n"
15558 " current plot to the specified device by switching to this stream and\n"
15559 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
15560 " appropriate. The plot buffer must have previously been enabled (done\n"
15561 " automatically by some display drivers, such as X).\n"
15562 "\n"
15563 " Redacted form: plcpstrm(iplsr, flags)\n"
15564 "\n"
15565 " This function is used in example 1,20.\n"
15566 "\n"
15567 "\n"
15568 "\n"
15569 "SYNOPSIS:\n"
15570 "\n"
15571 "plcpstrm(iplsr, flags)\n"
15572 "\n"
15573 "ARGUMENTS:\n"
15574 "\n"
15575 " iplsr (PLINT, input) : Number of reference stream.\n"
15576 "\n"
15577 " flags (PLBOOL, input) : If flags is set to true the device\n"
15578 " coordinates are not copied from the reference to current stream.\n"
15579 "\n"
15580 ""},
15581 { "plend", _wrap_plend, METH_NOARGS, "\n"
15582 "End plotting session\n"
15583 "\n"
15584 "DESCRIPTION:\n"
15585 "\n"
15586 " Ends a plotting session, tidies up all the output files, switches\n"
15587 " interactive devices back into text mode and frees up any memory that\n"
15588 " was allocated. Must be called before end of program.\n"
15589 "\n"
15590 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
15591 " wait state after a call to plend or other functions which trigger the\n"
15592 " end of a plot page. To avoid this, use the plspause function.\n"
15593 "\n"
15594 " Redacted form: plend()\n"
15595 "\n"
15596 " This function is used in all of the examples.\n"
15597 "\n"
15598 "\n"
15599 "\n"
15600 "SYNOPSIS:\n"
15601 "\n"
15602 "plend()\n"
15603 "\n"
15604 ""},
15605 { "plend1", _wrap_plend1, METH_NOARGS, "\n"
15606 "End plotting session for current stream\n"
15607 "\n"
15608 "DESCRIPTION:\n"
15609 "\n"
15610 " Ends a plotting session for the current output stream only. See\n"
15611 " plsstrm for more info.\n"
15612 "\n"
15613 " Redacted form: plend1()\n"
15614 "\n"
15615 " This function is used in examples 1 and 20.\n"
15616 "\n"
15617 "\n"
15618 "\n"
15619 "SYNOPSIS:\n"
15620 "\n"
15621 "plend1()\n"
15622 "\n"
15623 ""},
15624 { "plenv", _wrap_plenv, METH_VARARGS, "\n"
15625 "Set up standard window and draw box\n"
15626 "\n"
15627 "DESCRIPTION:\n"
15628 "\n"
15629 " Sets up plotter environment for simple graphs by calling pladv and\n"
15630 " setting up viewport and window to sensible default values. plenv\n"
15631 " leaves a standard margin (left-hand margin of eight character heights,\n"
15632 " and a margin around the other three sides of five character heights)\n"
15633 " around most graphs for axis labels and a title. When these defaults\n"
15634 " are not suitable, use the individual routines plvpas, plvpor, or\n"
15635 " plvasp for setting up the viewport, plwind for defining the window,\n"
15636 " and plbox for drawing the box.\n"
15637 "\n"
15638 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15639 "\n"
15640 " This function is used in example 1,3,9,13,14,19-22,29.\n"
15641 "\n"
15642 "\n"
15643 "\n"
15644 "SYNOPSIS:\n"
15645 "\n"
15646 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15647 "\n"
15648 "ARGUMENTS:\n"
15649 "\n"
15650 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15651 " world coordinates).\n"
15652 "\n"
15653 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15654 " world coordinates).\n"
15655 "\n"
15656 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15657 " coordinates).\n"
15658 "\n"
15659 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15660 " coordinates).\n"
15661 "\n"
15662 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15663 " scales will not be set, the user must set up the scale before\n"
15664 " calling plenv using plsvpa, plvasp or other.\n"
15665 " 0: the x and y axes are scaled independently to use as much of\n"
15666 " the screen as possible.\n"
15667 " 1: the scales of the x and y axes are made equal.\n"
15668 " 2: the axis of the x and y axes are made equal, and the plot\n"
15669 " box will be square.\n"
15670 "\n"
15671 "\n"
15672 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15673 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
15674 " -1: draw box only.\n"
15675 " 0: draw box, ticks, and numeric tick labels.\n"
15676 " 1: also draw coordinate axes at x=0 and y=0.\n"
15677 " 2: also draw a grid at major tick positions in both\n"
15678 " coordinates.\n"
15679 " 3: also draw a grid at minor tick positions in both\n"
15680 " coordinates.\n"
15681 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15682 " have to be converted to logarithms separately.)\n"
15683 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15684 " have to be converted to logarithms separately.)\n"
15685 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15686 " have to be converted to logarithms separately.)\n"
15687 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15688 " have to be converted to logarithms separately.)\n"
15689 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15690 " have to be converted to logarithms separately.)\n"
15691 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15692 " have to be converted to logarithms separately.)\n"
15693 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15694 " have to be converted to logarithms separately.)\n"
15695 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15696 " have to be converted to logarithms separately.)\n"
15697 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15698 " and y data have to be converted to logarithms separately.)\n"
15699 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15700 " and y data have to be converted to logarithms separately.)\n"
15701 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15702 " and y data have to be converted to logarithms separately.)\n"
15703 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15704 " and y data have to be converted to logarithms separately.)\n"
15705 " 40: same as 0 except date / time x labels.\n"
15706 " 41: same as 1 except date / time x labels.\n"
15707 " 42: same as 2 except date / time x labels.\n"
15708 " 43: same as 3 except date / time x labels.\n"
15709 " 50: same as 0 except date / time y labels.\n"
15710 " 51: same as 1 except date / time y labels.\n"
15711 " 52: same as 2 except date / time y labels.\n"
15712 " 53: same as 3 except date / time y labels.\n"
15713 " 60: same as 0 except date / time x and y labels.\n"
15714 " 61: same as 1 except date / time x and y labels.\n"
15715 " 62: same as 2 except date / time x and y labels.\n"
15716 " 63: same as 3 except date / time x and y labels.\n"
15717 " 70: same as 0 except custom x and y labels.\n"
15718 " 71: same as 1 except custom x and y labels.\n"
15719 " 72: same as 2 except custom x and y labels.\n"
15720 " 73: same as 3 except custom x and y labels.\n"
15721 "\n"
15722 ""},
15723 { "plenv0", _wrap_plenv0, METH_VARARGS, "\n"
15724 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
15725 "\n"
15726 "DESCRIPTION:\n"
15727 "\n"
15728 " Sets up plotter environment for simple graphs by calling pladv and\n"
15729 " setting up viewport and window to sensible default values. plenv0\n"
15730 " leaves a standard margin (left-hand margin of eight character heights,\n"
15731 " and a margin around the other three sides of five character heights)\n"
15732 " around most graphs for axis labels and a title. When these defaults\n"
15733 " are not suitable, use the individual routines plvpas, plvpor, or\n"
15734 " plvasp for setting up the viewport, plwind for defining the window,\n"
15735 " and plbox for drawing the box.\n"
15736 "\n"
15737 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15738 "\n"
15739 " This function is used in example 21.\n"
15740 "\n"
15741 "\n"
15742 "\n"
15743 "SYNOPSIS:\n"
15744 "\n"
15745 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
15746 "\n"
15747 "ARGUMENTS:\n"
15748 "\n"
15749 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15750 " world coordinates).\n"
15751 "\n"
15752 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15753 " world coordinates).\n"
15754 "\n"
15755 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15756 " coordinates).\n"
15757 "\n"
15758 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15759 " coordinates).\n"
15760 "\n"
15761 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15762 " scales will not be set, the user must set up the scale before\n"
15763 " calling plenv0 using plsvpa, plvasp or other.\n"
15764 " 0: the x and y axes are scaled independently to use as much of\n"
15765 " the screen as possible.\n"
15766 " 1: the scales of the x and y axes are made equal.\n"
15767 " 2: the axis of the x and y axes are made equal, and the plot\n"
15768 " box will be square.\n"
15769 "\n"
15770 "\n"
15771 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15772 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
15773 " -1: draw box only.\n"
15774 " 0: draw box, ticks, and numeric tick labels.\n"
15775 " 1: also draw coordinate axes at x=0 and y=0.\n"
15776 " 2: also draw a grid at major tick positions in both\n"
15777 " coordinates.\n"
15778 " 3: also draw a grid at minor tick positions in both\n"
15779 " coordinates.\n"
15780 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15781 " have to be converted to logarithms separately.)\n"
15782 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15783 " have to be converted to logarithms separately.)\n"
15784 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15785 " have to be converted to logarithms separately.)\n"
15786 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15787 " have to be converted to logarithms separately.)\n"
15788 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15789 " have to be converted to logarithms separately.)\n"
15790 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
15791 " have to be converted to logarithms separately.)\n"
15792 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
15793 " have to be converted to logarithms separately.)\n"
15794 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
15795 " have to be converted to logarithms separately.)\n"
15796 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
15797 " and y data have to be converted to logarithms separately.)\n"
15798 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
15799 " and y data have to be converted to logarithms separately.)\n"
15800 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
15801 " and y data have to be converted to logarithms separately.)\n"
15802 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
15803 " and y data have to be converted to logarithms separately.)\n"
15804 " 40: same as 0 except date / time x labels.\n"
15805 " 41: same as 1 except date / time x labels.\n"
15806 " 42: same as 2 except date / time x labels.\n"
15807 " 43: same as 3 except date / time x labels.\n"
15808 " 50: same as 0 except date / time y labels.\n"
15809 " 51: same as 1 except date / time y labels.\n"
15810 " 52: same as 2 except date / time y labels.\n"
15811 " 53: same as 3 except date / time y labels.\n"
15812 " 60: same as 0 except date / time x and y labels.\n"
15813 " 61: same as 1 except date / time x and y labels.\n"
15814 " 62: same as 2 except date / time x and y labels.\n"
15815 " 63: same as 3 except date / time x and y labels.\n"
15816 " 70: same as 0 except custom x and y labels.\n"
15817 " 71: same as 1 except custom x and y labels.\n"
15818 " 72: same as 2 except custom x and y labels.\n"
15819 " 73: same as 3 except custom x and y labels.\n"
15820 "\n"
15821 ""},
15822 { "pleop", _wrap_pleop, METH_NOARGS, "\n"
15823 "Eject current page\n"
15824 "\n"
15825 "DESCRIPTION:\n"
15826 "\n"
15827 " Clears the graphics screen of an interactive device, or ejects a page\n"
15828 " on a plotter. See plbop for more information.\n"
15829 "\n"
15830 " Redacted form: pleop()\n"
15831 "\n"
15832 " This function is used in example 2,14.\n"
15833 "\n"
15834 "\n"
15835 "\n"
15836 "SYNOPSIS:\n"
15837 "\n"
15838 "pleop()\n"
15839 "\n"
15840 ""},
15841 { "plerrx", _wrap_plerrx, METH_VARARGS, "\n"
15842 "Draw error bars in x direction\n"
15843 "\n"
15844 "DESCRIPTION:\n"
15845 "\n"
15846 " Draws a set of n error bars in x direction, the i'th error bar\n"
15847 " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
15848 " of the error bars are of length equal to the minor tick length\n"
15849 " (settable using plsmin).\n"
15850 "\n"
15851 " Redacted form: General: plerrx(xmin, ymax, y)\n"
15852 "\n"
15853 "\n"
15854 " This function is used in example 29.\n"
15855 "\n"
15856 "\n"
15857 "\n"
15858 "SYNOPSIS:\n"
15859 "\n"
15860 "plerrx(n, xmin, xmax, y)\n"
15861 "\n"
15862 "ARGUMENTS:\n"
15863 "\n"
15864 " n (PLINT, input) : Number of error bars to draw.\n"
15865 "\n"
15866 " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
15867 " of the left-hand endpoints of the error bars.\n"
15868 "\n"
15869 " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
15870 " of the right-hand endpoints of the error bars.\n"
15871 "\n"
15872 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
15873 " the error bars.\n"
15874 "\n"
15875 ""},
15876 { "plerry", _wrap_plerry, METH_VARARGS, "\n"
15877 "Draw error bars in the y direction\n"
15878 "\n"
15879 "DESCRIPTION:\n"
15880 "\n"
15881 " Draws a set of n error bars in the y direction, the i'th error bar\n"
15882 " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
15883 " of the error bars are of length equal to the minor tick length\n"
15884 " (settable using plsmin).\n"
15885 "\n"
15886 " Redacted form: General: plerry(x, ymin, ymax)\n"
15887 "\n"
15888 "\n"
15889 " This function is used in example 29.\n"
15890 "\n"
15891 "\n"
15892 "\n"
15893 "SYNOPSIS:\n"
15894 "\n"
15895 "plerry(n, x, ymin, ymax)\n"
15896 "\n"
15897 "ARGUMENTS:\n"
15898 "\n"
15899 " n (PLINT, input) : Number of error bars to draw.\n"
15900 "\n"
15901 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
15902 " the error bars.\n"
15903 "\n"
15904 " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
15905 " of the lower endpoints of the error bars.\n"
15906 "\n"
15907 " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
15908 " of the upper endpoints of the error bars.\n"
15909 "\n"
15910 ""},
15911 { "plfamadv", _wrap_plfamadv, METH_NOARGS, "\n"
15912 "Advance to the next family file on the next new page\n"
15913 "\n"
15914 "DESCRIPTION:\n"
15915 "\n"
15916 " Advance to the next family file on the next new page.\n"
15917 "\n"
15918 " Redacted form: plfamadv()\n"
15919 "\n"
15920 " This function is not used in any examples.\n"
15921 "\n"
15922 "\n"
15923 "\n"
15924 "SYNOPSIS:\n"
15925 "\n"
15926 "plfamadv()\n"
15927 "\n"
15928 ""},
15929 { "plfill", _wrap_plfill, METH_VARARGS, "\n"
15930 "Draw filled polygon\n"
15931 "\n"
15932 "DESCRIPTION:\n"
15933 "\n"
15934 " Fills the polygon defined by the n points (\n"
15935 " x[i],\n"
15936 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
15937 " style is a solid fill. The routine will automatically close the\n"
15938 " polygon between the last and first vertices. If multiple closed\n"
15939 " polygons are passed in x and y then plfill will fill in between them.\n"
15940 "\n"
15941 " Redacted form: plfill(x,y)\n"
15942 "\n"
15943 " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
15944 "\n"
15945 "\n"
15946 "\n"
15947 "SYNOPSIS:\n"
15948 "\n"
15949 "plfill(n, x, y)\n"
15950 "\n"
15951 "ARGUMENTS:\n"
15952 "\n"
15953 " n (PLINT, input) : Number of vertices in polygon.\n"
15954 "\n"
15955 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
15956 " vertices.\n"
15957 "\n"
15958 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
15959 " vertices.\n"
15960 "\n"
15961 ""},
15962 { "plfill3", _wrap_plfill3, METH_VARARGS, "\n"
15963 "Draw filled polygon in 3D\n"
15964 "\n"
15965 "DESCRIPTION:\n"
15966 "\n"
15967 " Fills the 3D polygon defined by the n points in the x, y, and z\n"
15968 " vectors using the pattern defined by plpsty or plpat. The routine\n"
15969 " will automatically close the polygon between the last and first\n"
15970 " vertices. If multiple closed polygons are passed in x, y, and z then\n"
15971 " plfill3 will fill in between them.\n"
15972 "\n"
15973 " Redacted form: General: plfill3(x, y, z)\n"
15974 "\n"
15975 "\n"
15976 " This function is used in example 15.\n"
15977 "\n"
15978 "\n"
15979 "\n"
15980 "SYNOPSIS:\n"
15981 "\n"
15982 "plfill3(n, x, y, z)\n"
15983 "\n"
15984 "ARGUMENTS:\n"
15985 "\n"
15986 " n (PLINT, input) : Number of vertices in polygon.\n"
15987 "\n"
15988 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
15989 " vertices.\n"
15990 "\n"
15991 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
15992 " vertices.\n"
15993 "\n"
15994 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
15995 " vertices.\n"
15996 "\n"
15997 ""},
15998 { "plgradient", _wrap_plgradient, METH_VARARGS, "\n"
15999 "Draw linear gradient inside polygon\n"
16000 "\n"
16001 "DESCRIPTION:\n"
16002 "\n"
16003 " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16004 " points (\n"
16005 " x[i],\n"
16006 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16007 " polygon coordinates and the gradient angle are all expressed in world\n"
16008 " coordinates. The angle from the x axis for both the rotated\n"
16009 " coordinate system and the gradient vector is specified by angle. The\n"
16010 " magnitude of the gradient vector is the difference between the maximum\n"
16011 " and minimum values of x for the vertices in the rotated coordinate\n"
16012 " system. The origin of the gradient vector can be interpreted as being\n"
16013 " anywhere on the line corresponding to the minimum x value for the\n"
16014 " vertices in the rotated coordinate system. The distance along the\n"
16015 " gradient vector is linearly transformed to the independent variable of\n"
16016 " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16017 " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16018 " color corresponding to the independent variable of cmap1. For more\n"
16019 " information about cmap1 (see the PLplot documentation).\n"
16020 "\n"
16021 " Redacted form: plgradient(x,y,angle)\n"
16022 "\n"
16023 " This function is used in examples 25 and 30.\n"
16024 "\n"
16025 "\n"
16026 "\n"
16027 "SYNOPSIS:\n"
16028 "\n"
16029 "plgradient(n, x, y, angle)\n"
16030 "\n"
16031 "ARGUMENTS:\n"
16032 "\n"
16033 " n (PLINT, input) : Number of vertices in polygon.\n"
16034 "\n"
16035 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16036 " vertices.\n"
16037 "\n"
16038 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16039 " vertices.\n"
16040 "\n"
16041 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16042 " axis.\n"
16043 "\n"
16044 ""},
16045 { "plflush", _wrap_plflush, METH_NOARGS, "\n"
16046 "Flushes the output stream\n"
16047 "\n"
16048 "DESCRIPTION:\n"
16049 "\n"
16050 " Flushes the output stream. Use sparingly, if at all.\n"
16051 "\n"
16052 " Redacted form: plflush()\n"
16053 "\n"
16054 " This function is used in examples 1 and 14.\n"
16055 "\n"
16056 "\n"
16057 "\n"
16058 "SYNOPSIS:\n"
16059 "\n"
16060 "plflush()\n"
16061 "\n"
16062 ""},
16063 { "plfont", _wrap_plfont, METH_O, "\n"
16064 "Set font\n"
16065 "\n"
16066 "DESCRIPTION:\n"
16067 "\n"
16068 " Sets the font used for subsequent text and symbols. For devices that\n"
16069 " still use Hershey fonts this routine has no effect unless the Hershey\n"
16070 " fonts with extended character set are loaded (see plfontld). For\n"
16071 " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16072 " this routine calls the plsfci routine with argument set up\n"
16073 " appropriately for the various cases below. However, this method of\n"
16074 " specifying the font for unicode-aware devices is deprecated, and the\n"
16075 " much more flexible method of calling plsfont directly is recommended\n"
16076 " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16077 "\n"
16078 " Redacted form: plfont(ifont)\n"
16079 "\n"
16080 " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16081 "\n"
16082 "\n"
16083 "\n"
16084 "SYNOPSIS:\n"
16085 "\n"
16086 "plfont(ifont)\n"
16087 "\n"
16088 "ARGUMENTS:\n"
16089 "\n"
16090 " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16091 " (simplest and fastest)\n"
16092 " 2: Serif font\n"
16093 " 3: Italic font\n"
16094 " 4: Script font\n"
16095 "\n"
16096 ""},
16097 { "plfontld", _wrap_plfontld, METH_O, "\n"
16098 "Load Hershey fonts\n"
16099 "\n"
16100 "DESCRIPTION:\n"
16101 "\n"
16102 " Loads the Hershey fonts used for text and symbols. This routine may\n"
16103 " be called before or after initializing PLplot. If not explicitly\n"
16104 " called before PLplot initialization, then by default that\n"
16105 " initialization loads Hershey fonts with the extended character set.\n"
16106 " This routine only has a practical effect for devices that still use\n"
16107 " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16108 " system fonts instead of Hershey fonts).\n"
16109 "\n"
16110 " Redacted form: plfontld(fnt)\n"
16111 "\n"
16112 " This function is used in examples 1 and 7.\n"
16113 "\n"
16114 "\n"
16115 "\n"
16116 "SYNOPSIS:\n"
16117 "\n"
16118 "plfontld(fnt)\n"
16119 "\n"
16120 "ARGUMENTS:\n"
16121 "\n"
16122 " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16123 " A zero value specifies Hershey fonts with the standard character\n"
16124 " set and a non-zero value (the default assumed if plfontld is never\n"
16125 " called) specifies Hershey fonts with the extended character set.\n"
16126 "\n"
16127 ""},
16128 { "plgchr", _wrap_plgchr, METH_NOARGS, "\n"
16129 "Get character default height and current (scaled) height\n"
16130 "\n"
16131 "DESCRIPTION:\n"
16132 "\n"
16133 " Get character default height and current (scaled) height.\n"
16134 "\n"
16135 " Redacted form: plgchr(p_def, p_ht)\n"
16136 "\n"
16137 " This function is used in example 23.\n"
16138 "\n"
16139 "\n"
16140 "\n"
16141 "SYNOPSIS:\n"
16142 "\n"
16143 "plgchr(p_def, p_ht)\n"
16144 "\n"
16145 "ARGUMENTS:\n"
16146 "\n"
16147 " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16148 " character height (mm).\n"
16149 "\n"
16150 " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16151 " character height (mm).\n"
16152 "\n"
16153 ""},
16154 { "plgcol0", _wrap_plgcol0, METH_O, "\n"
16155 "Returns 8-bit RGB values for given color index from cmap0\n"
16156 "\n"
16157 "DESCRIPTION:\n"
16158 "\n"
16159 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16160 " PLplot documentation). Values are negative if an invalid color id is\n"
16161 " given.\n"
16162 "\n"
16163 " Redacted form: plgcol0(icol0, r, g, b)\n"
16164 "\n"
16165 " This function is used in example 2.\n"
16166 "\n"
16167 "\n"
16168 "\n"
16169 "SYNOPSIS:\n"
16170 "\n"
16171 "plgcol0(icol0, r, g, b)\n"
16172 "\n"
16173 "ARGUMENTS:\n"
16174 "\n"
16175 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16176 "\n"
16177 " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16178 " value.\n"
16179 "\n"
16180 " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16181 " value.\n"
16182 "\n"
16183 " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16184 " value.\n"
16185 "\n"
16186 ""},
16187 { "plgcol0a", _wrap_plgcol0a, METH_O, "\n"
16188 "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16189 "\n"
16190 "DESCRIPTION:\n"
16191 "\n"
16192 " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16193 " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16194 " Values are negative if an invalid color id is given.\n"
16195 "\n"
16196 " Redacted form: plgcola(r, g, b)\n"
16197 "\n"
16198 " This function is used in example 30.\n"
16199 "\n"
16200 "\n"
16201 "\n"
16202 "SYNOPSIS:\n"
16203 "\n"
16204 "plgcol0a(icol0, r, g, b, alpha)\n"
16205 "\n"
16206 "ARGUMENTS:\n"
16207 "\n"
16208 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16209 "\n"
16210 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16211 " in the range from 0 to 255.\n"
16212 "\n"
16213 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16214 " in the range from 0 to 255.\n"
16215 "\n"
16216 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16217 " in the range from 0 to 255.\n"
16218 "\n"
16219 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16220 " transparency in the range from (0.0-1.0).\n"
16221 "\n"
16222 ""},
16223 { "plgcolbg", _wrap_plgcolbg, METH_NOARGS, "\n"
16224 "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16225 "\n"
16226 "DESCRIPTION:\n"
16227 "\n"
16228 " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16229 "\n"
16230 " Redacted form: plgcolbg(r, g, b)\n"
16231 "\n"
16232 " This function is used in example 31.\n"
16233 "\n"
16234 "\n"
16235 "\n"
16236 "SYNOPSIS:\n"
16237 "\n"
16238 "plgcolbg(r, g, b)\n"
16239 "\n"
16240 "ARGUMENTS:\n"
16241 "\n"
16242 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16243 " in the range from 0 to 255.\n"
16244 "\n"
16245 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16246 " in the range from 0 to 255.\n"
16247 "\n"
16248 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16249 " in the range from 0 to 255.\n"
16250 "\n"
16251 ""},
16252 { "plgcolbga", _wrap_plgcolbga, METH_NOARGS, "\n"
16253 "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
16254 "\n"
16255 "DESCRIPTION:\n"
16256 "\n"
16257 " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
16258 " alpha transparency value.\n"
16259 "\n"
16260 " This function is used in example 31.\n"
16261 "\n"
16262 "\n"
16263 "\n"
16264 "SYNOPSIS:\n"
16265 "\n"
16266 "plgcolbga(r, g, b, alpha)\n"
16267 "\n"
16268 "ARGUMENTS:\n"
16269 "\n"
16270 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16271 " in the range from 0 to 255.\n"
16272 "\n"
16273 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16274 " in the range from 0 to 255.\n"
16275 "\n"
16276 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16277 " in the range from 0 to 255.\n"
16278 "\n"
16279 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16280 " transparency in the range (0.0-1.0).\n"
16281 "\n"
16282 ""},
16283 { "plgcompression", _wrap_plgcompression, METH_NOARGS, "\n"
16284 "Get the current device-compression setting\n"
16285 "\n"
16286 "DESCRIPTION:\n"
16287 "\n"
16288 " Get the current device-compression setting. This parameter is only\n"
16289 " used for drivers that provide compression.\n"
16290 "\n"
16291 " Redacted form: plgcompression(compression)\n"
16292 "\n"
16293 " This function is used in example 31.\n"
16294 "\n"
16295 "\n"
16296 "\n"
16297 "SYNOPSIS:\n"
16298 "\n"
16299 "plgcompression(compression)\n"
16300 "\n"
16301 "ARGUMENTS:\n"
16302 "\n"
16303 " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
16304 " compression setting for the current device.\n"
16305 "\n"
16306 ""},
16307 { "plgdev", _wrap_plgdev, METH_NOARGS, "\n"
16308 "Get the current device (keyword) name\n"
16309 "\n"
16310 "DESCRIPTION:\n"
16311 "\n"
16312 " Get the current device (keyword) name. Note: you must have allocated\n"
16313 " space for this (80 characters is safe).\n"
16314 "\n"
16315 " Redacted form: plgdev(p_dev)\n"
16316 "\n"
16317 " This function is used in example 14.\n"
16318 "\n"
16319 "\n"
16320 "\n"
16321 "SYNOPSIS:\n"
16322 "\n"
16323 "plgdev(p_dev)\n"
16324 "\n"
16325 "ARGUMENTS:\n"
16326 "\n"
16327 " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16328 " (with preallocated length of 80 characters or more) containing the\n"
16329 " device (keyword) name.\n"
16330 "\n"
16331 ""},
16332 { "plgdidev", _wrap_plgdidev, METH_NOARGS, "\n"
16333 "Get parameters that define current device-space window\n"
16334 "\n"
16335 "DESCRIPTION:\n"
16336 "\n"
16337 " Get relative margin width, aspect ratio, and relative justification\n"
16338 " that define current device-space window. If plsdidev has not been\n"
16339 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16340 " p_jy will all be 0.\n"
16341 "\n"
16342 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16343 "\n"
16344 " This function is used in example 31.\n"
16345 "\n"
16346 "\n"
16347 "\n"
16348 "SYNOPSIS:\n"
16349 "\n"
16350 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16351 "\n"
16352 "ARGUMENTS:\n"
16353 "\n"
16354 " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16355 " margin width.\n"
16356 "\n"
16357 " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
16358 " ratio.\n"
16359 "\n"
16360 " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16361 " justification in x.\n"
16362 "\n"
16363 " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16364 " justification in y.\n"
16365 "\n"
16366 ""},
16367 { "plgdiori", _wrap_plgdiori, METH_NOARGS, "\n"
16368 "Get plot orientation\n"
16369 "\n"
16370 "DESCRIPTION:\n"
16371 "\n"
16372 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16373 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16374 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16375 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16376 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16377 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16378 " not been called the default value pointed to by p_rot will be 0.\n"
16379 "\n"
16380 " Redacted form: plgdiori(p_rot)\n"
16381 "\n"
16382 " This function is not used in any examples.\n"
16383 "\n"
16384 "\n"
16385 "\n"
16386 "SYNOPSIS:\n"
16387 "\n"
16388 "plgdiori(p_rot)\n"
16389 "\n"
16390 "ARGUMENTS:\n"
16391 "\n"
16392 " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
16393 " parameter.\n"
16394 "\n"
16395 ""},
16396 { "plgdiplt", _wrap_plgdiplt, METH_NOARGS, "\n"
16397 "Get parameters that define current plot-space window\n"
16398 "\n"
16399 "DESCRIPTION:\n"
16400 "\n"
16401 " Get relative minima and maxima that define current plot-space window.\n"
16402 " If plsdiplt has not been called the default values pointed to by\n"
16403 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
16404 "\n"
16405 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16406 "\n"
16407 " This function is used in example 31.\n"
16408 "\n"
16409 "\n"
16410 "\n"
16411 "SYNOPSIS:\n"
16412 "\n"
16413 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16414 "\n"
16415 "ARGUMENTS:\n"
16416 "\n"
16417 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16418 " minimum in x.\n"
16419 "\n"
16420 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16421 " minimum in y.\n"
16422 "\n"
16423 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16424 " maximum in x.\n"
16425 "\n"
16426 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16427 " maximum in y.\n"
16428 "\n"
16429 ""},
16430 { "plgfam", _wrap_plgfam, METH_NOARGS, "\n"
16431 "Get family file parameters\n"
16432 "\n"
16433 "DESCRIPTION:\n"
16434 "\n"
16435 " Gets information about current family file, if familying is enabled.\n"
16436 " See the PLplot documentation for more information.\n"
16437 "\n"
16438 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
16439 "\n"
16440 " This function is used in examples 14 and 31.\n"
16441 "\n"
16442 "\n"
16443 "\n"
16444 "SYNOPSIS:\n"
16445 "\n"
16446 "plgfam(p_fam, p_num, p_bmax)\n"
16447 "\n"
16448 "ARGUMENTS:\n"
16449 "\n"
16450 " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16451 " family flag value. If nonzero, familying is enabled for the\n"
16452 " current device.\n"
16453 "\n"
16454 " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16455 " family file number.\n"
16456 "\n"
16457 " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16458 " file size (in bytes) for a family file.\n"
16459 "\n"
16460 ""},
16461 { "plgfci", _wrap_plgfci, METH_NOARGS, "\n"
16462 "Get FCI (font characterization integer)\n"
16463 "\n"
16464 "DESCRIPTION:\n"
16465 "\n"
16466 " Gets information about the current font using the FCI approach. See\n"
16467 " the PLplot documentation for more information.\n"
16468 "\n"
16469 " Redacted form: plgfci(p_fci)\n"
16470 "\n"
16471 " This function is used in example 23.\n"
16472 "\n"
16473 "\n"
16474 "\n"
16475 "SYNOPSIS:\n"
16476 "\n"
16477 "plgfci(p_fci)\n"
16478 "\n"
16479 "ARGUMENTS:\n"
16480 "\n"
16481 " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
16482 " FCI value.\n"
16483 "\n"
16484 ""},
16485 { "plgfnam", _wrap_plgfnam, METH_NOARGS, "\n"
16486 "Get output file name\n"
16487 "\n"
16488 "DESCRIPTION:\n"
16489 "\n"
16490 " Gets the current output file name, if applicable.\n"
16491 "\n"
16492 " Redacted form: plgfnam(fnam)\n"
16493 "\n"
16494 " This function is used in example 31.\n"
16495 "\n"
16496 "\n"
16497 "\n"
16498 "SYNOPSIS:\n"
16499 "\n"
16500 "plgfnam(fnam)\n"
16501 "\n"
16502 "ARGUMENTS:\n"
16503 "\n"
16504 " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16505 " (with preallocated length of 80 characters or more) containing the\n"
16506 " file name.\n"
16507 "\n"
16508 ""},
16509 { "plgfont", _wrap_plgfont, METH_NOARGS, "\n"
16510 "Get family, style and weight of the current font\n"
16511 "\n"
16512 "DESCRIPTION:\n"
16513 "\n"
16514 " Gets information about current font. See the PLplot documentation for\n"
16515 " more information on font selection.\n"
16516 "\n"
16517 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
16518 "\n"
16519 " This function is used in example 23.\n"
16520 "\n"
16521 "\n"
16522 "\n"
16523 "SYNOPSIS:\n"
16524 "\n"
16525 "plgfont(p_family, p_style, p_weight)\n"
16526 "\n"
16527 "ARGUMENTS:\n"
16528 "\n"
16529 " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16530 " font family. The available values are given by the PL_FCI_*\n"
16531 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
16532 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
16533 " p_family is NULL then the font family is not returned.\n"
16534 "\n"
16535 " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16536 " font style. The available values are given by the PL_FCI_*\n"
16537 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
16538 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
16539 " style is not returned.\n"
16540 "\n"
16541 " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16542 " font weight. The available values are given by the PL_FCI_*\n"
16543 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
16544 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
16545 " returned.\n"
16546 "\n"
16547 ""},
16548 { "plglevel", _wrap_plglevel, METH_NOARGS, "\n"
16549 "Get the (current) run level\n"
16550 "\n"
16551 "DESCRIPTION:\n"
16552 "\n"
16553 " Get the (current) run level. Valid settings are: 0, uninitialized\n"
16554 " 1, initialized\n"
16555 " 2, viewport defined\n"
16556 " 3, world coordinates defined\n"
16557 "\n"
16558 "\n"
16559 " Redacted form: plglevel(p_level)\n"
16560 "\n"
16561 " This function is used in example 31.\n"
16562 "\n"
16563 "\n"
16564 "\n"
16565 "SYNOPSIS:\n"
16566 "\n"
16567 "plglevel(p_level)\n"
16568 "\n"
16569 "ARGUMENTS:\n"
16570 "\n"
16571 " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
16572 " level.\n"
16573 "\n"
16574 ""},
16575 { "plgpage", _wrap_plgpage, METH_NOARGS, "\n"
16576 "Get page parameters\n"
16577 "\n"
16578 "DESCRIPTION:\n"
16579 "\n"
16580 " Gets the current page configuration. The length and offset values are\n"
16581 " expressed in units that are specific to the current driver. For\n"
16582 " instance: screen drivers will usually interpret them as number of\n"
16583 " pixels, whereas printer drivers will usually use mm.\n"
16584 "\n"
16585 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
16586 "\n"
16587 " This function is used in examples 14 and 31.\n"
16588 "\n"
16589 "\n"
16590 "\n"
16591 "SYNOPSIS:\n"
16592 "\n"
16593 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
16594 "\n"
16595 "ARGUMENTS:\n"
16596 "\n"
16597 " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
16598 " pixels/inch (DPI) in x.\n"
16599 "\n"
16600 " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
16601 " pixels/inch (DPI) in y.\n"
16602 "\n"
16603 " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
16604 " length.\n"
16605 "\n"
16606 " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
16607 " length.\n"
16608 "\n"
16609 " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
16610 " offset.\n"
16611 "\n"
16612 " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
16613 " offset.\n"
16614 "\n"
16615 ""},
16616 { "plgra", _wrap_plgra, METH_NOARGS, "\n"
16617 "Switch to graphics screen\n"
16618 "\n"
16619 "DESCRIPTION:\n"
16620 "\n"
16621 " Sets an interactive device to graphics mode, used in conjunction with\n"
16622 " pltext to allow graphics and text to be interspersed. On a device\n"
16623 " which supports separate text and graphics windows, this command causes\n"
16624 " control to be switched to the graphics window. If already in graphics\n"
16625 " mode, this command is ignored. It is also ignored on devices which\n"
16626 " only support a single window or use a different method for shifting\n"
16627 " focus. See also pltext.\n"
16628 "\n"
16629 " Redacted form: plgra()\n"
16630 "\n"
16631 " This function is used in example 1.\n"
16632 "\n"
16633 "\n"
16634 "\n"
16635 "SYNOPSIS:\n"
16636 "\n"
16637 "plgra()\n"
16638 "\n"
16639 ""},
16640 { "plgriddata", _wrap_plgriddata, METH_VARARGS, "\n"
16641 "Grid data from irregularly sampled data\n"
16642 "\n"
16643 "DESCRIPTION:\n"
16644 "\n"
16645 " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
16646 " require data organized as a grid, i.e., with x sample point values\n"
16647 " independent of y coordinate and vice versa. This function takes\n"
16648 " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
16649 " vectors; reads the desired grid location from the input vectors\n"
16650 " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
16651 " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
16652 " interpolate the data to the grid is specified with the argument type\n"
16653 " which can have one parameter specified in argument data.\n"
16654 "\n"
16655 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
16656 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
16657 "\n"
16658 "\n"
16659 " This function is used in example 21.\n"
16660 "\n"
16661 "\n"
16662 "\n"
16663 "SYNOPSIS:\n"
16664 "\n"
16665 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
16666 "\n"
16667 "ARGUMENTS:\n"
16668 "\n"
16669 " x (PLFLT_VECTOR, input) : The input x vector.\n"
16670 "\n"
16671 " y (PLFLT_VECTOR, input) : The input y vector.\n"
16672 "\n"
16673 " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
16674 " y[i], z[i] represents one data sample coordinate.\n"
16675 "\n"
16676 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
16677 " vectors.\n"
16678 "\n"
16679 " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
16680 " in the x direction. Usually xg has nptsx equally spaced values\n"
16681 " from the minimum to the maximum values of the x input vector.\n"
16682 "\n"
16683 " nptsx (PLINT, input) : The number of points in the xg vector.\n"
16684 "\n"
16685 " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
16686 " in the y direction. Similar to the xg parameter.\n"
16687 "\n"
16688 " nptsy (PLINT, input) : The number of points in the yg vector.\n"
16689 "\n"
16690 " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
16691 " where data lies in the grid specified by xg and yg. Therefore the\n"
16692 " zg matrix must be dimensioned\n"
16693 " nptsx by\n"
16694 " nptsy.\n"
16695 "\n"
16696 " type (PLINT, input) : The type of grid interpolation algorithm to\n"
16697 " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
16698 " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
16699 " GRID_NNI: Natural Neighbors Interpolation\n"
16700 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
16701 " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
16702 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
16703 " Weighted\n"
16704 " For details of the algorithms read the source file plgridd.c.\n"
16705 "\n"
16706 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
16707 " which can be specified through this argument. Currently, for\n"
16708 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
16709 " use, the lower the value, the noisier (more local) the\n"
16710 " approximation is.\n"
16711 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
16712 " range [1. .. 2.]. High values enable the usage of very thin\n"
16713 " triangles for interpolation, possibly resulting in error in\n"
16714 " the approximation.\n"
16715 " GRID_NNI, only weights greater than data will be accepted. If\n"
16716 " 0, all weights will be accepted.\n"
16717 "\n"
16718 ""},
16719 { "plgspa", _wrap_plgspa, METH_NOARGS, "\n"
16720 "Get current subpage parameters\n"
16721 "\n"
16722 "DESCRIPTION:\n"
16723 "\n"
16724 " Gets the size of the current subpage in millimeters measured from the\n"
16725 " bottom left hand corner of the output device page or screen. Can be\n"
16726 " used in conjunction with plsvpa for setting the size of a viewport in\n"
16727 " absolute coordinates (millimeters).\n"
16728 "\n"
16729 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
16730 "\n"
16731 " This function is used in example 23.\n"
16732 "\n"
16733 "\n"
16734 "\n"
16735 "SYNOPSIS:\n"
16736 "\n"
16737 "plgspa(xmin, xmax, ymin, ymax)\n"
16738 "\n"
16739 "ARGUMENTS:\n"
16740 "\n"
16741 " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16742 " the left hand edge of the subpage in millimeters.\n"
16743 "\n"
16744 " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16745 " the right hand edge of the subpage in millimeters.\n"
16746 "\n"
16747 " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16748 " the bottom edge of the subpage in millimeters.\n"
16749 "\n"
16750 " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
16751 " the top edge of the subpage in millimeters.\n"
16752 "\n"
16753 ""},
16754 { "plgstrm", _wrap_plgstrm, METH_NOARGS, "\n"
16755 "Get current stream number\n"
16756 "\n"
16757 "DESCRIPTION:\n"
16758 "\n"
16759 " Gets the number of the current output stream. See also plsstrm.\n"
16760 "\n"
16761 " Redacted form: plgstrm(p_strm)\n"
16762 "\n"
16763 " This function is used in example 1,20.\n"
16764 "\n"
16765 "\n"
16766 "\n"
16767 "SYNOPSIS:\n"
16768 "\n"
16769 "plgstrm(p_strm)\n"
16770 "\n"
16771 "ARGUMENTS:\n"
16772 "\n"
16773 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16774 " stream value.\n"
16775 "\n"
16776 ""},
16777 { "plgver", _wrap_plgver, METH_NOARGS, "\n"
16778 "Get the current library version number\n"
16779 "\n"
16780 "DESCRIPTION:\n"
16781 "\n"
16782 " Get the current library version number. Note: you must have allocated\n"
16783 " space for this (80 characters is safe).\n"
16784 "\n"
16785 " Redacted form: plgver(p_ver)\n"
16786 "\n"
16787 " This function is used in example 1.\n"
16788 "\n"
16789 "\n"
16790 "\n"
16791 "SYNOPSIS:\n"
16792 "\n"
16793 "plgver(p_ver)\n"
16794 "\n"
16795 "ARGUMENTS:\n"
16796 "\n"
16797 " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16798 " (with preallocated length of 80 characters or more) containing the\n"
16799 " PLplot version number.\n"
16800 "\n"
16801 ""},
16802 { "plgvpd", _wrap_plgvpd, METH_NOARGS, "\n"
16803 "Get viewport limits in normalized device coordinates\n"
16804 "\n"
16805 "DESCRIPTION:\n"
16806 "\n"
16807 " Get viewport limits in normalized device coordinates.\n"
16808 "\n"
16809 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16810 "\n"
16811 "\n"
16812 " This function is used in example 31.\n"
16813 "\n"
16814 "\n"
16815 "\n"
16816 "SYNOPSIS:\n"
16817 "\n"
16818 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16819 "\n"
16820 "ARGUMENTS:\n"
16821 "\n"
16822 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16823 " viewport limit of the normalized device coordinate in x.\n"
16824 "\n"
16825 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16826 " viewport limit of the normalized device coordinate in x.\n"
16827 "\n"
16828 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16829 " viewport limit of the normalized device coordinate in y.\n"
16830 "\n"
16831 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16832 " viewport limit of the normalized device coordinate in y.\n"
16833 "\n"
16834 ""},
16835 { "plgvpw", _wrap_plgvpw, METH_NOARGS, "\n"
16836 "Get viewport limits in world coordinates\n"
16837 "\n"
16838 "DESCRIPTION:\n"
16839 "\n"
16840 " Get viewport limits in world coordinates.\n"
16841 "\n"
16842 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16843 "\n"
16844 "\n"
16845 " This function is used in example 31.\n"
16846 "\n"
16847 "\n"
16848 "\n"
16849 "SYNOPSIS:\n"
16850 "\n"
16851 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
16852 "\n"
16853 "ARGUMENTS:\n"
16854 "\n"
16855 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16856 " viewport limit of the world coordinate in x.\n"
16857 "\n"
16858 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16859 " viewport limit of the world coordinate in x.\n"
16860 "\n"
16861 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
16862 " viewport limit of the world coordinate in y.\n"
16863 "\n"
16864 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
16865 " viewport limit of the world coordinate in y.\n"
16866 "\n"
16867 ""},
16868 { "plgxax", _wrap_plgxax, METH_NOARGS, "\n"
16869 "Get x axis parameters\n"
16870 "\n"
16871 "DESCRIPTION:\n"
16872 "\n"
16873 " Returns current values of the p_digmax and p_digits flags for the x\n"
16874 " axis. p_digits is updated after the plot is drawn, so this routine\n"
16875 " should only be called after the call to plbox (or plbox3) is complete.\n"
16876 " See the PLplot documentation for more information.\n"
16877 "\n"
16878 " Redacted form: plgxax(p_digmax, p_digits)\n"
16879 "\n"
16880 " This function is used in example 31.\n"
16881 "\n"
16882 "\n"
16883 "\n"
16884 "SYNOPSIS:\n"
16885 "\n"
16886 "plgxax(p_digmax, p_digits)\n"
16887 "\n"
16888 "ARGUMENTS:\n"
16889 "\n"
16890 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16891 " number of digits for the x axis. If nonzero, the printed label\n"
16892 " has been switched to a floating-point representation when the\n"
16893 " number of digits exceeds this value.\n"
16894 "\n"
16895 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
16896 " number of digits for the numeric labels (x axis) from the last\n"
16897 " plot.\n"
16898 "\n"
16899 ""},
16900 { "plgyax", _wrap_plgyax, METH_NOARGS, "\n"
16901 "Get y axis parameters\n"
16902 "\n"
16903 "DESCRIPTION:\n"
16904 "\n"
16905 " Identical to plgxax, except that arguments are flags for y axis. See\n"
16906 " the description of plgxax for more detail.\n"
16907 "\n"
16908 " Redacted form: plgyax(p_digmax, p_digits)\n"
16909 "\n"
16910 " This function is used in example 31.\n"
16911 "\n"
16912 "\n"
16913 "\n"
16914 "SYNOPSIS:\n"
16915 "\n"
16916 "plgyax(p_digmax, p_digits)\n"
16917 "\n"
16918 "ARGUMENTS:\n"
16919 "\n"
16920 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16921 " number of digits for the y axis. If nonzero, the printed label\n"
16922 " has been switched to a floating-point representation when the\n"
16923 " number of digits exceeds this value.\n"
16924 "\n"
16925 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
16926 " number of digits for the numeric labels (y axis) from the last\n"
16927 " plot.\n"
16928 "\n"
16929 ""},
16930 { "plgzax", _wrap_plgzax, METH_NOARGS, "\n"
16931 "Get z axis parameters\n"
16932 "\n"
16933 "DESCRIPTION:\n"
16934 "\n"
16935 " Identical to plgxax, except that arguments are flags for z axis. See\n"
16936 " the description of plgxax for more detail.\n"
16937 "\n"
16938 " Redacted form: plgzax(p_digmax, p_digits)\n"
16939 "\n"
16940 " This function is used in example 31.\n"
16941 "\n"
16942 "\n"
16943 "\n"
16944 "SYNOPSIS:\n"
16945 "\n"
16946 "plgzax(p_digmax, p_digits)\n"
16947 "\n"
16948 "ARGUMENTS:\n"
16949 "\n"
16950 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16951 " number of digits for the z axis. If nonzero, the printed label\n"
16952 " has been switched to a floating-point representation when the\n"
16953 " number of digits exceeds this value.\n"
16954 "\n"
16955 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
16956 " number of digits for the numeric labels (z axis) from the last\n"
16957 " plot.\n"
16958 "\n"
16959 ""},
16960 { "plhist", _wrap_plhist, METH_VARARGS, "\n"
16961 "Plot a histogram from unbinned data\n"
16962 "\n"
16963 "DESCRIPTION:\n"
16964 "\n"
16965 " Plots a histogram from n data points stored in the data vector. This\n"
16966 " routine bins the data into nbin bins equally spaced between datmin and\n"
16967 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
16968 " opt allows, among other things, the histogram either to be plotted in\n"
16969 " an existing window or causes plhist to call plenv with suitable limits\n"
16970 " before plotting the histogram.\n"
16971 "\n"
16972 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
16973 "\n"
16974 " This function is used in example 5.\n"
16975 "\n"
16976 "\n"
16977 "\n"
16978 "SYNOPSIS:\n"
16979 "\n"
16980 "plhist(n, data, datmin, datmax, nbin, opt)\n"
16981 "\n"
16982 "ARGUMENTS:\n"
16983 "\n"
16984 " n (PLINT, input) : Number of data points.\n"
16985 "\n"
16986 " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
16987 " n data points.\n"
16988 "\n"
16989 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
16990 "\n"
16991 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
16992 "\n"
16993 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
16994 " divide the interval xmin to xmax.\n"
16995 "\n"
16996 " opt (PLINT, input) : Is a combination of several flags:\n"
16997 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
16998 " the histogram data, the outer bins are expanded to fill up the\n"
16999 " entire x-axis, data outside the given extremes are assigned to the\n"
17000 " outer bins and bins of zero height are simply drawn.\n"
17001 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17002 " to fit the histogram data, without this flag, plenv is called\n"
17003 " to set the world coordinates.\n"
17004 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17005 " extremes are not taken into account. This option should\n"
17006 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17007 " properly present the data.\n"
17008 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17009 " size as the ones inside.\n"
17010 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17011 " (there is a gap for such bins).\n"
17012 "\n"
17013 ""},
17014 { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, "\n"
17015 "Convert HLS color to RGB\n"
17016 "\n"
17017 "DESCRIPTION:\n"
17018 "\n"
17019 " Convert HLS color coordinates to RGB.\n"
17020 "\n"
17021 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17022 "\n"
17023 "\n"
17024 " This function is used in example 2.\n"
17025 "\n"
17026 "\n"
17027 "\n"
17028 "SYNOPSIS:\n"
17029 "\n"
17030 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17031 "\n"
17032 "ARGUMENTS:\n"
17033 "\n"
17034 " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17035 " cylinder.\n"
17036 "\n"
17037 " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17038 " the axis of the color cylinder.\n"
17039 "\n"
17040 " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17041 " the radius of the color cylinder.\n"
17042 "\n"
17043 " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17044 " (0.0-1.0) of the color.\n"
17045 "\n"
17046 " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17047 " intensity (0.0-1.0) of the color.\n"
17048 "\n"
17049 " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17050 " intensity (0.0-1.0) of the color.\n"
17051 "\n"
17052 ""},
17053 { "plinit", _wrap_plinit, METH_NOARGS, "\n"
17054 "Initialize PLplot\n"
17055 "\n"
17056 "DESCRIPTION:\n"
17057 "\n"
17058 " Initializing the plotting package. The program prompts for the device\n"
17059 " keyword or number of the desired output device. Hitting a RETURN in\n"
17060 " response to the prompt is the same as selecting the first device.\n"
17061 " plinit will issue no prompt if either the device was specified\n"
17062 " previously (via command line flag, the plsetopt function, or the\n"
17063 " plsdev function), or if only one device is enabled when PLplot is\n"
17064 " installed. If subpages have been specified, the output device is\n"
17065 " divided into nx by ny subpages, each of which may be used\n"
17066 " independently. If plinit is called again during a program, the\n"
17067 " previously opened file will be closed. The subroutine pladv is used\n"
17068 " to advance from one subpage to the next.\n"
17069 "\n"
17070 " Redacted form: plinit()\n"
17071 "\n"
17072 " This function is used in all of the examples.\n"
17073 "\n"
17074 "\n"
17075 "\n"
17076 "SYNOPSIS:\n"
17077 "\n"
17078 "plinit()\n"
17079 "\n"
17080 ""},
17081 { "pljoin", _wrap_pljoin, METH_VARARGS, "\n"
17082 "Draw a line between two points\n"
17083 "\n"
17084 "DESCRIPTION:\n"
17085 "\n"
17086 " Joins the point (\n"
17087 " x1,\n"
17088 " y1) to (\n"
17089 " x2,\n"
17090 " y2).\n"
17091 "\n"
17092 " Redacted form: pljoin(x1,y1,x2,y2)\n"
17093 "\n"
17094 " This function is used in examples 3 and 14.\n"
17095 "\n"
17096 "\n"
17097 "\n"
17098 "SYNOPSIS:\n"
17099 "\n"
17100 "pljoin(x1, y1, x2, y2)\n"
17101 "\n"
17102 "ARGUMENTS:\n"
17103 "\n"
17104 " x1 (PLFLT, input) : x coordinate of first point.\n"
17105 "\n"
17106 " y1 (PLFLT, input) : y coordinate of first point.\n"
17107 "\n"
17108 " x2 (PLFLT, input) : x coordinate of second point.\n"
17109 "\n"
17110 " y2 (PLFLT, input) : y coordinate of second point.\n"
17111 "\n"
17112 ""},
17113 { "pllab", _wrap_pllab, METH_VARARGS, "\n"
17114 "Simple routine to write labels\n"
17115 "\n"
17116 "DESCRIPTION:\n"
17117 "\n"
17118 " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17119 "\n"
17120 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17121 "\n"
17122 " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17123 "\n"
17124 "\n"
17125 "\n"
17126 "SYNOPSIS:\n"
17127 "\n"
17128 "pllab(xlabel, ylabel, tlabel)\n"
17129 "\n"
17130 "ARGUMENTS:\n"
17131 "\n"
17132 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17133 " the label for the x axis.\n"
17134 "\n"
17135 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17136 " the label for the y axis.\n"
17137 "\n"
17138 " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17139 " the title of the plot.\n"
17140 "\n"
17141 ""},
17142 { "pllegend", _wrap_pllegend, METH_VARARGS, "\n"
17143 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17144 "\n"
17145 "DESCRIPTION:\n"
17146 "\n"
17147 " Routine for creating a discrete plot legend with a plotted filled box,\n"
17148 " line, and/or line of symbols for each annotated legend entry. (See\n"
17149 " plcolorbar for similar functionality for creating continuous color\n"
17150 " bars.) The arguments of pllegend provide control over the location\n"
17151 " and size of the legend as well as the location and characteristics of\n"
17152 " the elements (most of which are optional) within that legend. The\n"
17153 " resulting legend is clipped at the boundaries of the current subpage.\n"
17154 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17155 " defined in the documentation of the position parameter.)\n"
17156 "\n"
17157 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17158 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17159 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17160 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17161 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17162 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17163 "\n"
17164 " This function is used in examples 4, 26, and 33.\n"
17165 "\n"
17166 "\n"
17167 "\n"
17168 "SYNOPSIS:\n"
17169 "\n"
17170 "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"
17171 "\n"
17172 "ARGUMENTS:\n"
17173 "\n"
17174 " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17175 " legend width in adopted coordinates. This quantity is calculated\n"
17176 " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17177 " the routine depending on nlegend and nrow), and the length\n"
17178 " (calculated internally) of the longest text string.\n"
17179 "\n"
17180 " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17181 " legend height in adopted coordinates. This quantity is calculated\n"
17182 " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17183 " the routine depending on nlegend and nrow).\n"
17184 "\n"
17185 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17186 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17187 " on the left of the legend and the plotted area on the right.\n"
17188 " Otherwise, put the text area on the right of the legend and the\n"
17189 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17190 " plot a (semitransparent) background for the legend. If the\n"
17191 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17192 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17193 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17194 " plot the resulting array of legend entries in row-major order.\n"
17195 " Otherwise, plot the legend entries in column-major order.\n"
17196 "\n"
17197 " position (PLINT, input) : position contains bits which control the\n"
17198 " overall position of the legend and the definition of the adopted\n"
17199 " coordinates used for positions just like what is done for the\n"
17200 " position argument for plcolorbar. However, note that the defaults\n"
17201 " for the position bits (see below) are different than the\n"
17202 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17203 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17204 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17205 " the 16 possible standard positions (the 4 corners and centers of\n"
17206 " the 4 sides for both the inside and outside cases) of the legend\n"
17207 " relative to the adopted coordinate system. The corner positions\n"
17208 " are specified by the appropriate combination of two of the\n"
17209 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17210 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17211 " value of one of those bits. The adopted coordinates are\n"
17212 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17213 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17214 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17215 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17216 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17217 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17218 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17219 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17220 "\n"
17221 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17222 " coordinates from the specified standard position of the legend.\n"
17223 " For positive x, the direction of motion away from the standard\n"
17224 " position is inward/outward from the standard corner positions or\n"
17225 " standard left or right positions if the\n"
17226 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17227 " For the standard top or bottom positions, the direction of motion\n"
17228 " is toward positive X.\n"
17229 "\n"
17230 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17231 " coordinates from the specified standard position of the legend.\n"
17232 " For positive y, the direction of motion away from the standard\n"
17233 " position is inward/outward from the standard corner positions or\n"
17234 " standard top or bottom positions if the\n"
17235 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17236 " the standard left or right positions, the direction of motion is\n"
17237 " toward positive Y.\n"
17238 "\n"
17239 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17240 " of the plot area (where the colored boxes, lines, and/or lines of\n"
17241 " symbols are drawn) of the legend.\n"
17242 "\n"
17243 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17244 " legend (PL_LEGEND_BACKGROUND).\n"
17245 "\n"
17246 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17247 " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17248 "\n"
17249 " bb_style (PLINT, input) : The pllsty style number for the\n"
17250 " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
17251 "\n"
17252 " nrow (PLINT, input) : The number of rows in the matrix used to\n"
17253 " render the\n"
17254 " nlegend legend entries. For internal transformations of\n"
17255 " nrow, see further remarks under\n"
17256 " nlegend.\n"
17257 "\n"
17258 " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
17259 " to render the\n"
17260 " nlegend legend entries. For internal transformations of\n"
17261 " ncolumn, see further remarks under\n"
17262 " nlegend.\n"
17263 "\n"
17264 " nlegend (PLINT, input) : Number of legend entries. The above\n"
17265 " nrow and\n"
17266 " ncolumn values are transformed internally to be consistent with\n"
17267 " nlegend. If either\n"
17268 " nrow or\n"
17269 " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
17270 " of\n"
17271 " nrow and\n"
17272 " ncolumn is less than\n"
17273 " nlegend, the smaller of the two (or\n"
17274 " nrow, if\n"
17275 " nrow ==\n"
17276 " ncolumn) is increased so the product is >=\n"
17277 " nlegend. Thus, for example, the common\n"
17278 " nrow = 0,\n"
17279 " ncolumn = 0 case is transformed internally to\n"
17280 " nrow =\n"
17281 " nlegend,\n"
17282 " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
17283 " column.\n"
17284 "\n"
17285 " opt_array (PLINT_VECTOR, input) : A vector of\n"
17286 " nlegend values of options to control each individual plotted area\n"
17287 " corresponding to a legend entry. If the\n"
17288 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17289 " area. If the\n"
17290 " PL_LEGEND_COLOR_BOX,\n"
17291 " PL_LEGEND_LINE, and/or\n"
17292 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17293 " entry is plotted with a colored box; a line; and/or a line of\n"
17294 " symbols.\n"
17295 "\n"
17296 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17297 " area in units of character width.\n"
17298 "\n"
17299 " text_scale (PLFLT, input) : Character height scale for text\n"
17300 " annotations.\n"
17301 "\n"
17302 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17303 " character height from one legend entry to the next.\n"
17304 "\n"
17305 " text_justification (PLFLT, input) : Justification parameter used\n"
17306 " for text justification. The most common values of\n"
17307 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17308 " is left justified, centred, or right justified within the text\n"
17309 " area, but other values are allowed as well.\n"
17310 "\n"
17311 " text_colors (PLINT_VECTOR, input) : A vector containing\n"
17312 " nlegend cmap0 text colors.\n"
17313 "\n"
17314 " text (PLCHAR_MATRIX, input) : A vector of\n"
17315 " nlegend UTF-8 character strings containing the legend annotations.\n"
17316 "\n"
17317 " box_colors (PLINT_VECTOR, input) : A vector containing\n"
17318 " nlegend cmap0 colors for the discrete colored boxes (\n"
17319 " PL_LEGEND_COLOR_BOX).\n"
17320 "\n"
17321 " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
17322 " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
17323 " PL_LEGEND_COLOR_BOX).\n"
17324 "\n"
17325 " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
17326 " nlegend scales (units of fraction of character height) for the height\n"
17327 " of the discrete colored boxes (\n"
17328 " PL_LEGEND_COLOR_BOX).\n"
17329 "\n"
17330 " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17331 " nlegend line widths for the patterns specified by box_patterns (\n"
17332 " PL_LEGEND_COLOR_BOX).\n"
17333 "\n"
17334 " line_colors (PLINT_VECTOR, input) : A vector containing\n"
17335 " nlegend cmap0 line colors (\n"
17336 " PL_LEGEND_LINE).\n"
17337 "\n"
17338 " line_styles (PLINT_VECTOR, input) : A vector containing\n"
17339 " nlegend line styles (plsty indices) (\n"
17340 " PL_LEGEND_LINE).\n"
17341 "\n"
17342 " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17343 " nlegend line widths (\n"
17344 " PL_LEGEND_LINE).\n"
17345 "\n"
17346 " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
17347 " nlegend cmap0 symbol colors (\n"
17348 " PL_LEGEND_SYMBOL).\n"
17349 "\n"
17350 " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
17351 " nlegend scale values for the symbol height (\n"
17352 " PL_LEGEND_SYMBOL).\n"
17353 "\n"
17354 " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
17355 " nlegend numbers of symbols to be drawn across the width of the plotted\n"
17356 " area (\n"
17357 " PL_LEGEND_SYMBOL).\n"
17358 "\n"
17359 " symbols (PLCHAR_MATRIX, input) : A vector of\n"
17360 " nlegend UTF-8 character strings containing the legend symbols. (\n"
17361 " PL_LEGEND_SYMBOL).\n"
17362 "\n"
17363 ""},
17364 { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, "\n"
17365 "Plot color bar for image, shade or gradient plots\n"
17366 "\n"
17367 "DESCRIPTION:\n"
17368 "\n"
17369 " Routine for creating a continuous color bar for image, shade, or\n"
17370 " gradient plots. (See pllegend for similar functionality for creating\n"
17371 " legends with discrete elements). The arguments of plcolorbar provide\n"
17372 " control over the location and size of the color bar as well as the\n"
17373 " location and characteristics of the elements (most of which are\n"
17374 " optional) within that color bar. The resulting color bar is clipped\n"
17375 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
17376 " system used for some of the parameters is defined in the documentation\n"
17377 " of the position parameter.)\n"
17378 "\n"
17379 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
17380 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
17381 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
17382 " labels, axis_opts, ticks, sub_ticks, values)\n"
17383 "\n"
17384 " This function is used in examples 16 and 33.\n"
17385 "\n"
17386 "\n"
17387 "\n"
17388 "SYNOPSIS:\n"
17389 "\n"
17390 "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"
17391 "\n"
17392 "ARGUMENTS:\n"
17393 "\n"
17394 " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17395 " labelled and decorated color bar width in adopted coordinates.\n"
17396 "\n"
17397 " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17398 " labelled and decorated color bar height in adopted coordinates.\n"
17399 "\n"
17400 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17401 " color bar. The orientation (direction of the maximum value) of\n"
17402 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
17403 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
17404 " specified, the default orientation is toward the top if the\n"
17405 " colorbar is placed on the left or right of the viewport or toward\n"
17406 " the right if the colorbar is placed on the top or bottom of the\n"
17407 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
17408 " (semitransparent) background for the color bar. If the\n"
17409 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17410 " color bar. The type of color bar must be specified with one of\n"
17411 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
17412 " more than one of those bits is set only the first one in the above\n"
17413 " list is honored. The position of the (optional) label/title can be\n"
17414 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
17415 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
17416 " will be drawn. If more than one of this list of bits is specified,\n"
17417 " only the first one on the list is honored. End-caps for the color\n"
17418 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
17419 " If a particular color bar cap option is not specified then no cap\n"
17420 " will be drawn for that end. As a special case for\n"
17421 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
17422 " specified. If this option is provided then any tick marks and tick\n"
17423 " labels will be placed at the breaks between shaded segments. TODO:\n"
17424 " This should be expanded to support custom placement of tick marks\n"
17425 " and tick labels at custom value locations for any color bar type.\n"
17426 "\n"
17427 " position (PLINT, input) : position contains bits which control the\n"
17428 " overall position of the color bar and the definition of the\n"
17429 " adopted coordinates used for positions just like what is done for\n"
17430 " the position argument for pllegend. However, note that the\n"
17431 " defaults for the position bits (see below) are different than the\n"
17432 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
17433 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17434 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17435 " the 16 possible standard positions (the 4 corners and centers of\n"
17436 " the 4 sides for both the inside and outside cases) of the color\n"
17437 " bar relative to the adopted coordinate system. The corner\n"
17438 " positions are specified by the appropriate combination of two of\n"
17439 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17440 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17441 " value of one of those bits. The adopted coordinates are\n"
17442 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17443 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17444 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17445 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17446 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
17447 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
17448 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
17449 " PL_POSITION_VIEWPORT.\n"
17450 "\n"
17451 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
17452 " coordinates from the specified standard position of the color bar.\n"
17453 " For positive x, the direction of motion away from the standard\n"
17454 " position is inward/outward from the standard corner positions or\n"
17455 " standard left or right positions if the\n"
17456 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17457 " For the standard top or bottom positions, the direction of motion\n"
17458 " is toward positive X.\n"
17459 "\n"
17460 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
17461 " coordinates from the specified standard position of the color bar.\n"
17462 " For positive y, the direction of motion away from the standard\n"
17463 " position is inward/outward from the standard corner positions or\n"
17464 " standard top or bottom positions if the\n"
17465 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17466 " For the standard left or right positions, the direction of motion\n"
17467 " is toward positive Y.\n"
17468 "\n"
17469 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
17470 " the X direction in adopted coordinates.\n"
17471 "\n"
17472 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
17473 " the Y direction in adopted coordinates.\n"
17474 "\n"
17475 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17476 " color bar (PL_COLORBAR_BACKGROUND).\n"
17477 "\n"
17478 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17479 " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
17480 "\n"
17481 " bb_style (PLINT, input) : The pllsty style number for the\n"
17482 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
17483 "\n"
17484 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
17485 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
17486 "\n"
17487 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
17488 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
17489 "\n"
17490 " cont_color (PLINT, input) : The cmap0 contour color for\n"
17491 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
17492 " it will be interpreted according to the design of plshades.\n"
17493 "\n"
17494 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
17495 " plots. This is passed directly to plshades, so it will be\n"
17496 " interpreted according to the design of plshades.\n"
17497 "\n"
17498 " n_labels (PLINT, input) : Number of labels to place around the\n"
17499 " color bar.\n"
17500 "\n"
17501 " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
17502 " n_labels labels.\n"
17503 "\n"
17504 " labels (PLCHAR_MATRIX, input) : A vector of\n"
17505 " n_labels UTF-8 character strings containing the labels for the color\n"
17506 " bar. Ignored if no label position is specified with one of the\n"
17507 " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
17508 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
17509 " corresponding label_opts field.\n"
17510 "\n"
17511 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
17512 " value must be greater than 0. It is typically 1 (numerical axis\n"
17513 " labels are provided for one of the long edges of the color bar),\n"
17514 " but it can be larger if multiple numerical axis labels for the\n"
17515 " long edges of the color bar are desired.\n"
17516 "\n"
17517 " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
17518 " n_axes ascii character strings containing options (interpreted as for\n"
17519 " plbox) for the color bar's axis definitions.\n"
17520 "\n"
17521 " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
17522 " spacing of the major tick marks (interpreted as for plbox) for the\n"
17523 " color bar's axis definitions.\n"
17524 "\n"
17525 " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
17526 " number of subticks (interpreted as for plbox) for the color bar's\n"
17527 " axis definitions.\n"
17528 "\n"
17529 " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
17530 " elements in each of the n_axes rows of the values matrix.\n"
17531 "\n"
17532 " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
17533 " values for the data range represented by the color bar. For a row\n"
17534 " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
17535 " elements in the row is specified by n_values[i_axis]. For\n"
17536 " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
17537 " is 2, and the corresponding row elements of the values matrix are\n"
17538 " the minimum and maximum value represented by the colorbar. For\n"
17539 " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
17540 " of the values matrix is interpreted the same as the nlevel and\n"
17541 " clevel arguments of plshades.\n"
17542 "\n"
17543 ""},
17544 { "pllightsource", _wrap_pllightsource, METH_VARARGS, "\n"
17545 "Sets the 3D position of the light source\n"
17546 "\n"
17547 "DESCRIPTION:\n"
17548 "\n"
17549 " Sets the 3D position of the light source for use with plsurf3d and\n"
17550 " plsurf3dl\n"
17551 "\n"
17552 " Redacted form: pllightsource(x, y, z)\n"
17553 "\n"
17554 " This function is used in example 8.\n"
17555 "\n"
17556 "\n"
17557 "\n"
17558 "SYNOPSIS:\n"
17559 "\n"
17560 "pllightsource(x, y, z)\n"
17561 "\n"
17562 "ARGUMENTS:\n"
17563 "\n"
17564 " x (PLFLT, input) : X-coordinate of the light source.\n"
17565 "\n"
17566 " y (PLFLT, input) : Y-coordinate of the light source.\n"
17567 "\n"
17568 " z (PLFLT, input) : Z-coordinate of the light source.\n"
17569 "\n"
17570 ""},
17571 { "plline", _wrap_plline, METH_VARARGS, "\n"
17572 "Draw a line\n"
17573 "\n"
17574 "DESCRIPTION:\n"
17575 "\n"
17576 " Draws line defined by n points in x and y.\n"
17577 "\n"
17578 " Redacted form: plline(x, y)\n"
17579 "\n"
17580 " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
17581 " 25-27, and 29.\n"
17582 "\n"
17583 "\n"
17584 "\n"
17585 "SYNOPSIS:\n"
17586 "\n"
17587 "plline(n, x, y)\n"
17588 "\n"
17589 "ARGUMENTS:\n"
17590 "\n"
17591 " n (PLINT, input) : Number of points defining line.\n"
17592 "\n"
17593 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
17594 " points.\n"
17595 "\n"
17596 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
17597 " points.\n"
17598 "\n"
17599 ""},
17600 { "plline3", _wrap_plline3, METH_VARARGS, "\n"
17601 "Draw a line in 3 space\n"
17602 "\n"
17603 "DESCRIPTION:\n"
17604 "\n"
17605 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
17606 " first set up the viewport, the 2d viewing window (in world\n"
17607 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
17608 " more info.\n"
17609 "\n"
17610 " Redacted form: plline3(x, y, z)\n"
17611 "\n"
17612 " This function is used in example 18.\n"
17613 "\n"
17614 "\n"
17615 "\n"
17616 "SYNOPSIS:\n"
17617 "\n"
17618 "plline3(n, x, y, z)\n"
17619 "\n"
17620 "ARGUMENTS:\n"
17621 "\n"
17622 " n (PLINT, input) : Number of points defining line.\n"
17623 "\n"
17624 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
17625 " points.\n"
17626 "\n"
17627 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
17628 " points.\n"
17629 "\n"
17630 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
17631 " points.\n"
17632 "\n"
17633 ""},
17634 { "pllsty", _wrap_pllsty, METH_O, "\n"
17635 "Select line style\n"
17636 "\n"
17637 "DESCRIPTION:\n"
17638 "\n"
17639 " This sets the line style according to one of eight predefined patterns\n"
17640 " (also see plstyl).\n"
17641 "\n"
17642 " Redacted form: pllsty(lin)\n"
17643 "\n"
17644 " This function is used in examples 9, 12, 22, and 25.\n"
17645 "\n"
17646 "\n"
17647 "\n"
17648 "SYNOPSIS:\n"
17649 "\n"
17650 "pllsty(lin)\n"
17651 "\n"
17652 "ARGUMENTS:\n"
17653 "\n"
17654 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
17655 " a continuous line, line style 2 is a line with short dashes and\n"
17656 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
17657 " 4 has long dashes and short gaps and so on.\n"
17658 "\n"
17659 ""},
17660 { "plmesh", _wrap_plmesh, METH_VARARGS, "\n"
17661 "Plot surface mesh\n"
17662 "\n"
17663 "DESCRIPTION:\n"
17664 "\n"
17665 " Plots a surface mesh within the environment set up by plw3d. The\n"
17666 " surface is defined by the matrix z[\n"
17667 " nx][\n"
17668 " ny] , the point z[i][j] being the value of the function at (\n"
17669 " x[i],\n"
17670 " y[j]). Note that the points in vectors x and y do not need to be\n"
17671 " equally spaced, but must be stored in ascending order. The parameter\n"
17672 " opt controls the way in which the surface is displayed. For further\n"
17673 " details see the PLplot documentation.\n"
17674 "\n"
17675 " Redacted form: plmesh(x, y, z, opt)\n"
17676 "\n"
17677 " This function is used in example 11.\n"
17678 "\n"
17679 "\n"
17680 "\n"
17681 "SYNOPSIS:\n"
17682 "\n"
17683 "plmesh(x, y, z, nx, ny, opt)\n"
17684 "\n"
17685 "ARGUMENTS:\n"
17686 "\n"
17687 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17688 " which the function is evaluated.\n"
17689 "\n"
17690 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17691 " which the function is evaluated.\n"
17692 "\n"
17693 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17694 " plot. Should have dimensions of\n"
17695 " nx by\n"
17696 " ny.\n"
17697 "\n"
17698 " nx (PLINT, input) : Number of x values at which function has been\n"
17699 " evaluated.\n"
17700 "\n"
17701 " ny (PLINT, input) : Number of y values at which function has been\n"
17702 " evaluated.\n"
17703 "\n"
17704 " opt (PLINT, input) : Determines the way in which the surface is\n"
17705 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
17706 " function of x for each value of y[j] .\n"
17707 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17708 " for each value of x[i] .\n"
17709 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
17710 " at which function is defined.\n"
17711 "\n"
17712 ""},
17713 { "plmeshc", _wrap_plmeshc, METH_VARARGS, "\n"
17714 "Magnitude colored plot surface mesh with contour\n"
17715 "\n"
17716 "DESCRIPTION:\n"
17717 "\n"
17718 " A more powerful form of plmesh: the surface mesh can be colored\n"
17719 " accordingly to the current z value being plotted, a contour plot can\n"
17720 " be drawn at the base XY plane, and a curtain can be drawn between the\n"
17721 " plotted function border and the base XY plane.\n"
17722 "\n"
17723 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
17724 "\n"
17725 " This function is used in example 11.\n"
17726 "\n"
17727 "\n"
17728 "\n"
17729 "SYNOPSIS:\n"
17730 "\n"
17731 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
17732 "\n"
17733 "ARGUMENTS:\n"
17734 "\n"
17735 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17736 " which the function is evaluated.\n"
17737 "\n"
17738 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17739 " which the function is evaluated.\n"
17740 "\n"
17741 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17742 " plot. Should have dimensions of\n"
17743 " nx by\n"
17744 " ny.\n"
17745 "\n"
17746 " nx (PLINT, input) : Number of x values at which function is\n"
17747 " evaluated.\n"
17748 "\n"
17749 " ny (PLINT, input) : Number of y values at which function is\n"
17750 " evaluated.\n"
17751 "\n"
17752 " opt (PLINT, input) : Determines the way in which the surface is\n"
17753 " represented. To specify more than one option just add the options,\n"
17754 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
17755 " showing z as a function of x for each value of y[j] .\n"
17756 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17757 " for each value of x[i] .\n"
17758 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
17759 " at which function is defined.\n"
17760 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
17761 " the z value being plotted. The color is used from the current\n"
17762 " cmap1.\n"
17763 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
17764 " using parameters\n"
17765 " nlevel and\n"
17766 " clevel.\n"
17767 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
17768 " the borders of the plotted function.\n"
17769 "\n"
17770 "\n"
17771 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
17772 " levels.\n"
17773 "\n"
17774 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
17775 "\n"
17776 ""},
17777 { "plmkstrm", _wrap_plmkstrm, METH_NOARGS, "\n"
17778 "Creates a new stream and makes it the default\n"
17779 "\n"
17780 "DESCRIPTION:\n"
17781 "\n"
17782 " Creates a new stream and makes it the default. Differs from using\n"
17783 " plsstrm, in that a free stream number is found, and returned.\n"
17784 " Unfortunately, I have to start at stream 1 and work upward, since\n"
17785 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
17786 " that no initial, library-opening call is required. So stream 0 must\n"
17787 " be preallocated, and there is no simple way of determining whether it\n"
17788 " is already in use or not.\n"
17789 "\n"
17790 " Redacted form: plmkstrm(p_strm)\n"
17791 "\n"
17792 " This function is used in examples 1 and 20.\n"
17793 "\n"
17794 "\n"
17795 "\n"
17796 "SYNOPSIS:\n"
17797 "\n"
17798 "plmkstrm(p_strm)\n"
17799 "\n"
17800 "ARGUMENTS:\n"
17801 "\n"
17802 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
17803 " number of the created stream.\n"
17804 "\n"
17805 ""},
17806 { "plmtex", _wrap_plmtex, METH_VARARGS, "\n"
17807 "Write text relative to viewport boundaries\n"
17808 "\n"
17809 "DESCRIPTION:\n"
17810 "\n"
17811 " Writes text at a specified position relative to the viewport\n"
17812 " boundaries. Text may be written inside or outside the viewport, but\n"
17813 " is clipped at the subpage boundaries. The reference point of a string\n"
17814 " lies along a line passing through the string at half the height of a\n"
17815 " capital letter. The position of the reference point along this line\n"
17816 " is determined by just, and the position of the reference point\n"
17817 " relative to the viewport is set by disp and pos.\n"
17818 "\n"
17819 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
17820 "\n"
17821 "\n"
17822 " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
17823 " 26.\n"
17824 "\n"
17825 "\n"
17826 "\n"
17827 "SYNOPSIS:\n"
17828 "\n"
17829 "plmtex(side, disp, pos, just, text)\n"
17830 "\n"
17831 "ARGUMENTS:\n"
17832 "\n"
17833 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
17834 " the side of the viewport along which the text is to be written.\n"
17835 " The string must be one of: b: Bottom of viewport, text written\n"
17836 " parallel to edge.\n"
17837 " bv: Bottom of viewport, text written at right angles to edge.\n"
17838 " l: Left of viewport, text written parallel to edge.\n"
17839 " lv: Left of viewport, text written at right angles to edge.\n"
17840 " r: Right of viewport, text written parallel to edge.\n"
17841 " rv: Right of viewport, text written at right angles to edge.\n"
17842 " t: Top of viewport, text written parallel to edge.\n"
17843 " tv: Top of viewport, text written at right angles to edge.\n"
17844 "\n"
17845 "\n"
17846 " disp (PLFLT, input) : Position of the reference point of string,\n"
17847 " measured outwards from the specified viewport edge in units of the\n"
17848 " current character height. Use negative disp to write within the\n"
17849 " viewport.\n"
17850 "\n"
17851 " pos (PLFLT, input) : Position of the reference point of string\n"
17852 " along the specified edge, expressed as a fraction of the length of\n"
17853 " the edge.\n"
17854 "\n"
17855 " just (PLFLT, input) : Specifies the position of the string relative\n"
17856 " to its reference point. If just=0. , the reference point is at\n"
17857 " the left and if just=1. , it is at the right of the string. Other\n"
17858 " values of just give intermediate justifications.\n"
17859 "\n"
17860 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
17861 " written out.\n"
17862 "\n"
17863 ""},
17864 { "plmtex3", _wrap_plmtex3, METH_VARARGS, "\n"
17865 "Write text relative to viewport boundaries in 3D plots\n"
17866 "\n"
17867 "DESCRIPTION:\n"
17868 "\n"
17869 " Writes text at a specified position relative to the viewport\n"
17870 " boundaries. Text may be written inside or outside the viewport, but\n"
17871 " is clipped at the subpage boundaries. The reference point of a string\n"
17872 " lies along a line passing through the string at half the height of a\n"
17873 " capital letter. The position of the reference point along this line\n"
17874 " is determined by just, and the position of the reference point\n"
17875 " relative to the viewport is set by disp and pos.\n"
17876 "\n"
17877 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
17878 "\n"
17879 " This function is used in example 28.\n"
17880 "\n"
17881 "\n"
17882 "\n"
17883 "SYNOPSIS:\n"
17884 "\n"
17885 "plmtex3(side, disp, pos, just, text)\n"
17886 "\n"
17887 "ARGUMENTS:\n"
17888 "\n"
17889 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
17890 " the side of the viewport along which the text is to be written.\n"
17891 " The string should contain one or more of the following characters:\n"
17892 " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
17893 " only label the X axis, not both the X and Y axes. x: Label the X\n"
17894 " axis.\n"
17895 " y: Label the Y axis.\n"
17896 " z: Label the Z axis.\n"
17897 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
17898 " For X it is the axis that starts at y-min. For Y it is the\n"
17899 " axis that starts at x-min.\n"
17900 " s: Label the secondary axis.\n"
17901 " v: Draw the text perpendicular to the axis.\n"
17902 "\n"
17903 "\n"
17904 " disp (PLFLT, input) : Position of the reference point of string,\n"
17905 " measured outwards from the specified viewport edge in units of the\n"
17906 " current character height. Use negative disp to write within the\n"
17907 " viewport.\n"
17908 "\n"
17909 " pos (PLFLT, input) : Position of the reference point of string\n"
17910 " along the specified edge, expressed as a fraction of the length of\n"
17911 " the edge.\n"
17912 "\n"
17913 " just (PLFLT, input) : Specifies the position of the string relative\n"
17914 " to its reference point. If just=0. , the reference point is at\n"
17915 " the left and if just=1. , it is at the right of the string. Other\n"
17916 " values of just give intermediate justifications.\n"
17917 "\n"
17918 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
17919 " written out.\n"
17920 "\n"
17921 ""},
17922 { "plot3d", _wrap_plot3d, METH_VARARGS, "\n"
17923 "Plot 3-d surface plot\n"
17924 "\n"
17925 "DESCRIPTION:\n"
17926 "\n"
17927 " Plots a three-dimensional surface plot within the environment set up\n"
17928 " by plw3d. The surface is defined by the matrix z[\n"
17929 " nx][\n"
17930 " ny] , the point z[i][j] being the value of the function at (\n"
17931 " x[i],\n"
17932 " y[j]). Note that the points in vectors x and y do not need to be\n"
17933 " equally spaced, but must be stored in ascending order. The parameter\n"
17934 " opt controls the way in which the surface is displayed. For further\n"
17935 " details see the PLplot documentation. The only difference between\n"
17936 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
17937 " while plot3d only draws the surface as viewed from the top.\n"
17938 "\n"
17939 " Redacted form: plot3d(x, y, z, opt, side)\n"
17940 "\n"
17941 " This function is used in examples 11 and 21.\n"
17942 "\n"
17943 "\n"
17944 "\n"
17945 "SYNOPSIS:\n"
17946 "\n"
17947 "plot3d(x, y, z, nx, ny, opt, side)\n"
17948 "\n"
17949 "ARGUMENTS:\n"
17950 "\n"
17951 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17952 " which the function is evaluated.\n"
17953 "\n"
17954 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17955 " which the function is evaluated.\n"
17956 "\n"
17957 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
17958 " plot. Should have dimensions of\n"
17959 " nx by\n"
17960 " ny.\n"
17961 "\n"
17962 " nx (PLINT, input) : Number of x values at which function is\n"
17963 " evaluated.\n"
17964 "\n"
17965 " ny (PLINT, input) : Number of y values at which function is\n"
17966 " evaluated.\n"
17967 "\n"
17968 " opt (PLINT, input) : Determines the way in which the surface is\n"
17969 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
17970 " function of x for each value of y[j] .\n"
17971 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
17972 " for each value of x[i] .\n"
17973 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
17974 " at which function is defined.\n"
17975 "\n"
17976 "\n"
17977 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
17978 " should be draw on the figure. If side is true sides are drawn,\n"
17979 " otherwise no sides are drawn.\n"
17980 "\n"
17981 ""},
17982 { "plot3dc", _wrap_plot3dc, METH_VARARGS, "\n"
17983 "Magnitude colored plot surface with contour\n"
17984 "\n"
17985 "DESCRIPTION:\n"
17986 "\n"
17987 " Aside from dropping the\n"
17988 " side functionality this is a more powerful form of plot3d: the surface\n"
17989 " mesh can be colored accordingly to the current z value being plotted,\n"
17990 " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
17991 " drawn between the plotted function border and the base XY plane. The\n"
17992 " arguments are identical to those of plmeshc. The only difference\n"
17993 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
17994 " the surface, while plot3dc only draws the surface as viewed from the\n"
17995 " top.\n"
17996 "\n"
17997 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
17998 "\n"
17999 "\n"
18000 " This function is used in example 21.\n"
18001 "\n"
18002 "\n"
18003 "\n"
18004 "SYNOPSIS:\n"
18005 "\n"
18006 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18007 "\n"
18008 "ARGUMENTS:\n"
18009 "\n"
18010 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18011 " which the function is evaluated.\n"
18012 "\n"
18013 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18014 " which the function is evaluated.\n"
18015 "\n"
18016 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18017 " plot. Should have dimensions of\n"
18018 " nx by\n"
18019 " ny.\n"
18020 "\n"
18021 " nx (PLINT, input) : Number of x values at which function is\n"
18022 " evaluated.\n"
18023 "\n"
18024 " ny (PLINT, input) : Number of y values at which function is\n"
18025 " evaluated.\n"
18026 "\n"
18027 " opt (PLINT, input) : Determines the way in which the surface is\n"
18028 " represented. To specify more than one option just add the options,\n"
18029 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18030 " showing z as a function of x for each value of y[j] .\n"
18031 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18032 " for each value of x[i] .\n"
18033 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18034 " at which function is defined.\n"
18035 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18036 " the z value being plotted. The color is used from the current\n"
18037 " cmap1.\n"
18038 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18039 " using parameters\n"
18040 " nlevel and\n"
18041 " clevel.\n"
18042 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18043 " the borders of the plotted function.\n"
18044 "\n"
18045 "\n"
18046 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18047 " levels.\n"
18048 "\n"
18049 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18050 "\n"
18051 ""},
18052 { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, "\n"
18053 "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18054 "\n"
18055 "DESCRIPTION:\n"
18056 "\n"
18057 " When the implementation is completed this variant of plot3dc (see that\n"
18058 " function's documentation for more details) should be suitable for the\n"
18059 " case where the area of the x, y coordinate grid where z is defined can\n"
18060 " be non-rectangular. The implementation is incomplete so the last 4\n"
18061 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18062 " indexymax; are currently ignored and the functionality is otherwise\n"
18063 " identical to that of plot3dc.\n"
18064 "\n"
18065 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18066 " indexymin, indexymax)\n"
18067 "\n"
18068 "\n"
18069 " This function is not used in any example.\n"
18070 "\n"
18071 "\n"
18072 "\n"
18073 "SYNOPSIS:\n"
18074 "\n"
18075 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18076 "\n"
18077 "ARGUMENTS:\n"
18078 "\n"
18079 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18080 " which the function is evaluated.\n"
18081 "\n"
18082 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18083 " which the function is evaluated.\n"
18084 "\n"
18085 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18086 " plot. Should have dimensions of\n"
18087 " nx by\n"
18088 " ny.\n"
18089 "\n"
18090 " nx (PLINT, input) : Number of x values at which the function is\n"
18091 " evaluated.\n"
18092 "\n"
18093 " ny (PLINT, input) : Number of y values at which the function is\n"
18094 " evaluated.\n"
18095 "\n"
18096 " opt (PLINT, input) : Determines the way in which the surface is\n"
18097 " represented. To specify more than one option just add the options,\n"
18098 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18099 " showing z as a function of x for each value of y[j] .\n"
18100 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18101 " for each value of x[i] .\n"
18102 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18103 " at which function is defined.\n"
18104 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18105 " the z value being plotted. The color is used from the current\n"
18106 " cmap1.\n"
18107 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18108 " using parameters\n"
18109 " nlevel and\n"
18110 " clevel.\n"
18111 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18112 " the borders of the plotted function.\n"
18113 "\n"
18114 "\n"
18115 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18116 " levels.\n"
18117 "\n"
18118 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18119 "\n"
18120 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18121 " corresponds to the first x index where z is defined.\n"
18122 "\n"
18123 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18124 " which corresponds (by convention) to one more than the last x\n"
18125 " index value where z is defined.\n"
18126 "\n"
18127 " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18128 " values which all must be ≥ 0. These values are the first y index\n"
18129 " where z is defined for a particular x index in the range from\n"
18130 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18131 " indexxmax.\n"
18132 "\n"
18133 " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18134 " values which all must be ≤ ny. These values correspond (by\n"
18135 " convention) to one more than the last y index where z is defined\n"
18136 " for a particular x index in the range from indexxmin to indexxmax\n"
18137 " - 1. The dimension of indexymax is indexxmax.\n"
18138 "\n"
18139 ""},
18140 { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, "\n"
18141 "Plot shaded 3-d surface plot\n"
18142 "\n"
18143 "DESCRIPTION:\n"
18144 "\n"
18145 " Plots a three-dimensional shaded surface plot within the environment\n"
18146 " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18147 " z[\n"
18148 " nx][\n"
18149 " ny], the point z[i][j] being the value of the function at (\n"
18150 " x[i],\n"
18151 " y[j]). Note that the points in vectors x and y do not need to be\n"
18152 " equally spaced, but must be stored in ascending order. For further\n"
18153 " details see the PLplot documentation.\n"
18154 "\n"
18155 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18156 "\n"
18157 " This function is not used in any examples.\n"
18158 "\n"
18159 "\n"
18160 "\n"
18161 "SYNOPSIS:\n"
18162 "\n"
18163 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18164 "\n"
18165 "ARGUMENTS:\n"
18166 "\n"
18167 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18168 " which the function is evaluated.\n"
18169 "\n"
18170 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18171 " which the function is evaluated.\n"
18172 "\n"
18173 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18174 " plot. Should have dimensions of\n"
18175 " nx by\n"
18176 " ny.\n"
18177 "\n"
18178 " nx (PLINT, input) : Number of x values at which function is\n"
18179 " evaluated.\n"
18180 "\n"
18181 " ny (PLINT, input) : Number of y values at which function is\n"
18182 " evaluated.\n"
18183 "\n"
18184 " opt (PLINT, input) : Determines the way in which the surface is\n"
18185 " represented. To specify more than one option just add the options,\n"
18186 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18187 " connecting points at which function is defined.\n"
18188 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18189 " using parameters\n"
18190 " nlevel and\n"
18191 " clevel.\n"
18192 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18193 " using parameters\n"
18194 " nlevel and\n"
18195 " clevel.\n"
18196 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18197 " the borders of the plotted function.\n"
18198 " opt=MAG_COLOR : the surface is colored according to the value\n"
18199 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18200 " according to the intensity of the reflected light in the\n"
18201 " surface from a light source whose position is set using\n"
18202 " pllightsource.\n"
18203 "\n"
18204 "\n"
18205 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18206 " levels.\n"
18207 "\n"
18208 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18209 "\n"
18210 ""},
18211 { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, "\n"
18212 "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18213 "\n"
18214 "DESCRIPTION:\n"
18215 "\n"
18216 " This variant of plsurf3d (see that function's documentation for more\n"
18217 " details) should be suitable for the case where the area of the x, y\n"
18218 " coordinate grid where z is defined can be non-rectangular. The limits\n"
18219 " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18220 " indexymin, and indexymax.\n"
18221 "\n"
18222 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18223 " indexymax)\n"
18224 "\n"
18225 " This function is used in example 8.\n"
18226 "\n"
18227 "\n"
18228 "\n"
18229 "SYNOPSIS:\n"
18230 "\n"
18231 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18232 "\n"
18233 "ARGUMENTS:\n"
18234 "\n"
18235 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18236 " which the function is evaluated.\n"
18237 "\n"
18238 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18239 " which the function is evaluated.\n"
18240 "\n"
18241 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18242 " plot. Should have dimensions of\n"
18243 " nx by\n"
18244 " ny.\n"
18245 "\n"
18246 " nx (PLINT, input) : Number of x values at which function is\n"
18247 " evaluated.\n"
18248 "\n"
18249 " ny (PLINT, input) : Number of y values at which function is\n"
18250 " evaluated.\n"
18251 "\n"
18252 " opt (PLINT, input) : Determines the way in which the surface is\n"
18253 " represented. To specify more than one option just add the options,\n"
18254 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18255 " connecting points at which function is defined.\n"
18256 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18257 " using parameters\n"
18258 " nlevel and\n"
18259 " clevel.\n"
18260 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18261 " using parameters\n"
18262 " nlevel and\n"
18263 " clevel.\n"
18264 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18265 " the borders of the plotted function.\n"
18266 " opt=MAG_COLOR : the surface is colored according to the value\n"
18267 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18268 " according to the intensity of the reflected light in the\n"
18269 " surface from a light source whose position is set using\n"
18270 " pllightsource.\n"
18271 "\n"
18272 "\n"
18273 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18274 " levels.\n"
18275 "\n"
18276 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18277 "\n"
18278 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18279 " corresponds to the first x index where z is defined.\n"
18280 "\n"
18281 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18282 " which corresponds (by convention) to one more than the last x\n"
18283 " index value where z is defined.\n"
18284 "\n"
18285 " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
18286 " values which all must be ≥ 0. These values are the first y index\n"
18287 " where z is defined for a particular x index in the range from\n"
18288 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18289 " indexxmax.\n"
18290 "\n"
18291 " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
18292 " values which all must be ≤ ny. These values correspond (by\n"
18293 " convention) to one more than the last y index where z is defined\n"
18294 " for a particular x index in the range from indexxmin to indexxmax\n"
18295 " - 1. The dimension of indexymax is indexxmax.\n"
18296 "\n"
18297 ""},
18298 { "plparseopts", _wrap_plparseopts, METH_VARARGS, "\n"
18299 "Parse command-line arguments\n"
18300 "\n"
18301 "DESCRIPTION:\n"
18302 "\n"
18303 " Parse command-line arguments.\n"
18304 "\n"
18305 " plparseopts removes all recognized flags (decreasing argc\n"
18306 " accordingly), so that invalid input may be readily detected. It can\n"
18307 " also be used to process user command line flags. The user can merge\n"
18308 " an option table of type PLOptionTable into the internal option table\n"
18309 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
18310 " the external table(s) be parsed by calling plClearOpts before\n"
18311 " plMergeOpts.\n"
18312 "\n"
18313 " The default action taken by plparseopts is as follows:\n"
18314 " Returns with an error if an unrecognized option or badly formed\n"
18315 " option-value pair are encountered.\n"
18316 " Returns immediately (return code 0) when the first non-option command\n"
18317 " line argument is found.\n"
18318 " Returns with the return code of the option handler, if one was called.\n"
18319 "\n"
18320 " Deletes command line arguments from argv list as they are found, and\n"
18321 " decrements argc accordingly.\n"
18322 " Does not show \"invisible\" options in usage or help messages.\n"
18323 " Assumes the program name is contained in argv[0].\n"
18324 "\n"
18325 " These behaviors may be controlled through the\n"
18326 " mode argument.\n"
18327 "\n"
18328 " Redacted form: General: plparseopts(argv, mode)\n"
18329 "\n"
18330 "\n"
18331 " This function is used in all of the examples.\n"
18332 "\n"
18333 "\n"
18334 "\n"
18335 "SYNOPSIS:\n"
18336 "\n"
18337 "PLINT plparseopts(p_argc, argv, mode)\n"
18338 "\n"
18339 "ARGUMENTS:\n"
18340 "\n"
18341 " p_argc (int *, input/output) : Number of arguments.\n"
18342 "\n"
18343 " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
18344 " strings containing *p_argc command-line arguments.\n"
18345 "\n"
18346 " mode (PLINT, input) : Parsing mode with the following\n"
18347 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
18348 " and all error messages enabled, including program exit when an\n"
18349 " error occurs. Anything on the command line that isn't recognized\n"
18350 " as a valid option or option argument is flagged as an error.\n"
18351 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
18352 " of errors.\n"
18353 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
18354 " arguments.\n"
18355 " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
18356 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
18357 " pointer to the program name.\n"
18358 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
18359 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
18360 " unrecognized arguments.\n"
18361 "\n"
18362 ""},
18363 { "plpat", _wrap_plpat, METH_VARARGS, "\n"
18364 "Set area line fill pattern\n"
18365 "\n"
18366 "DESCRIPTION:\n"
18367 "\n"
18368 " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
18369 " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
18370 " inclinations and spacings. The arguments to this routine are the\n"
18371 " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
18372 " elements) specifying the inclinations in tenths of a degree and the\n"
18373 " spacing in micrometers. (See also plpsty)\n"
18374 "\n"
18375 " Redacted form: General: plpat(inc, del)\n"
18376 "\n"
18377 "\n"
18378 " This function is used in example 15.\n"
18379 "\n"
18380 "\n"
18381 "\n"
18382 "SYNOPSIS:\n"
18383 "\n"
18384 "plpat(nlin, inc, del)\n"
18385 "\n"
18386 "ARGUMENTS:\n"
18387 "\n"
18388 " nlin (PLINT, input) : Number of sets of lines making up the\n"
18389 " pattern, either 1 or 2.\n"
18390 "\n"
18391 " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18392 " inclination in tenths of a degree. (Should be between -900 and\n"
18393 " 900).\n"
18394 "\n"
18395 " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18396 " spacing in micrometers between the lines making up the pattern.\n"
18397 "\n"
18398 ""},
18399 { "plpath", _wrap_plpath, METH_VARARGS, "\n"
18400 "Draw a line between two points, accounting for coordinate transforms\n"
18401 "\n"
18402 "DESCRIPTION:\n"
18403 "\n"
18404 " Joins the point (\n"
18405 " x1,\n"
18406 " y1) to (\n"
18407 " x2,\n"
18408 " y2) . If a global coordinate transform is defined then the line is\n"
18409 " broken in to n segments to approximate the path. If no transform is\n"
18410 " defined then this simply acts like a call to pljoin.\n"
18411 "\n"
18412 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
18413 "\n"
18414 " This function is used in example 22.\n"
18415 "\n"
18416 "\n"
18417 "\n"
18418 "SYNOPSIS:\n"
18419 "\n"
18420 "plpath(n, x1, y1, x2, y2)\n"
18421 "\n"
18422 "ARGUMENTS:\n"
18423 "\n"
18424 " n (PLINT, input) : number of points to use to approximate the path.\n"
18425 "\n"
18426 " x1 (PLFLT, input) : x coordinate of first point.\n"
18427 "\n"
18428 " y1 (PLFLT, input) : y coordinate of first point.\n"
18429 "\n"
18430 " x2 (PLFLT, input) : x coordinate of second point.\n"
18431 "\n"
18432 " y2 (PLFLT, input) : y coordinate of second point.\n"
18433 "\n"
18434 ""},
18435 { "plpoin", _wrap_plpoin, METH_VARARGS, "\n"
18436 "Plot a glyph at the specified points\n"
18437 "\n"
18438 "DESCRIPTION:\n"
18439 "\n"
18440 " Plot a glyph at the specified points. (This function is largely\n"
18441 " superseded by plstring which gives access to many[!] more glyphs.)\n"
18442 " code=-1 means try to just draw a point. Right now it's just a move\n"
18443 " and a draw at the same place. Not ideal, since a sufficiently\n"
18444 " intelligent output device may optimize it away, or there may be faster\n"
18445 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18446 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18447 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18448 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18449 " code <= 127 the corresponding printable ASCII character is plotted.\n"
18450 "\n"
18451 " Redacted form: plpoin(x, y, code)\n"
18452 "\n"
18453 " This function is used in examples 1, 6, 14, and 29.\n"
18454 "\n"
18455 "\n"
18456 "\n"
18457 "SYNOPSIS:\n"
18458 "\n"
18459 "plpoin(n, x, y, code)\n"
18460 "\n"
18461 "ARGUMENTS:\n"
18462 "\n"
18463 " n (PLINT, input) : Number of points in the x and y vectors.\n"
18464 "\n"
18465 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18466 " points.\n"
18467 "\n"
18468 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18469 " points.\n"
18470 "\n"
18471 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18472 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18473 " each of the n points.\n"
18474 "\n"
18475 ""},
18476 { "plpoin3", _wrap_plpoin3, METH_VARARGS, "\n"
18477 "Plot a glyph at the specified 3D points\n"
18478 "\n"
18479 "DESCRIPTION:\n"
18480 "\n"
18481 " Plot a glyph at the specified 3D points. (This function is largely\n"
18482 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
18483 " Set up the call to this function similar to what is done for plline3.\n"
18484 " code=-1 means try to just draw a point. Right now it's just a move\n"
18485 " and a draw at the same place. Not ideal, since a sufficiently\n"
18486 " intelligent output device may optimize it away, or there may be faster\n"
18487 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18488 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18489 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18490 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18491 " code <= 127 the corresponding printable ASCII character is plotted.\n"
18492 "\n"
18493 " Redacted form: plpoin3(x, y, z, code)\n"
18494 "\n"
18495 " This function is not used in any example.\n"
18496 "\n"
18497 "\n"
18498 "\n"
18499 "SYNOPSIS:\n"
18500 "\n"
18501 "plpoin3(n, x, y, z, code)\n"
18502 "\n"
18503 "ARGUMENTS:\n"
18504 "\n"
18505 " n (PLINT, input) : Number of points in the x and y vectors.\n"
18506 "\n"
18507 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18508 " points.\n"
18509 "\n"
18510 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18511 " points.\n"
18512 "\n"
18513 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18514 " points.\n"
18515 "\n"
18516 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18517 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18518 " each of the n points.\n"
18519 "\n"
18520 ""},
18521 { "plpoly3", _wrap_plpoly3, METH_VARARGS, "\n"
18522 "Draw a polygon in 3 space\n"
18523 "\n"
18524 "DESCRIPTION:\n"
18525 "\n"
18526 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
18527 " like plline3, but differs from that function in that plpoly3 attempts\n"
18528 " to determine if the polygon is viewable depending on the order of the\n"
18529 " points within the vector and the value of ifcc. If the back of\n"
18530 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
18531 " you want, then use plline3 instead.\n"
18532 "\n"
18533 " The points are assumed to be in a plane, and the directionality of the\n"
18534 " plane is determined from the first three points. Additional points do\n"
18535 " not have to lie on the plane defined by the first three, but if they\n"
18536 " do not, then the determination of visibility obviously can't be 100%\n"
18537 " accurate... So if you're 3 space polygons are too far from planar,\n"
18538 " consider breaking them into smaller polygons. 3 points define a plane\n"
18539 " :-).\n"
18540 "\n"
18541 " Bugs: If one of the first two segments is of zero length, or if they\n"
18542 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
18543 " being correct. Avoid such situations :-). See x18c.c for an example\n"
18544 " of this problem. (Search for 20.1).\n"
18545 "\n"
18546 " Redacted form: plpoly3(x, y, z, code)\n"
18547 "\n"
18548 " This function is used in example 18.\n"
18549 "\n"
18550 "\n"
18551 "\n"
18552 "SYNOPSIS:\n"
18553 "\n"
18554 "plpoly3(n, x, y, z, draw, ifcc)\n"
18555 "\n"
18556 "ARGUMENTS:\n"
18557 "\n"
18558 " n (PLINT, input) : Number of points defining line.\n"
18559 "\n"
18560 " x (PLFLT_VECTOR, input) : A vector containing\n"
18561 " n x coordinates of points.\n"
18562 "\n"
18563 " y (PLFLT_VECTOR, input) : A vector containing\n"
18564 " n y coordinates of points.\n"
18565 "\n"
18566 " z (PLFLT_VECTOR, input) : A vector containing\n"
18567 " n z coordinates of points.\n"
18568 "\n"
18569 " draw (PLBOOL_VECTOR, input) : A vector containing\n"
18570 " n-1 Boolean values which control drawing the segments of the polygon.\n"
18571 " If draw[i] is true, then the polygon segment from index [i] to\n"
18572 " [i+1] is drawn, otherwise, not.\n"
18573 "\n"
18574 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
18575 " polygon is determined by assuming the points are laid out in a\n"
18576 " counter-clockwise order. Otherwise, the directionality of the\n"
18577 " polygon is determined by assuming the points are laid out in a\n"
18578 " clockwise order.\n"
18579 "\n"
18580 ""},
18581 { "plprec", _wrap_plprec, METH_VARARGS, "\n"
18582 "Set precision in numeric labels\n"
18583 "\n"
18584 "DESCRIPTION:\n"
18585 "\n"
18586 " Sets the number of places after the decimal point in numeric labels.\n"
18587 "\n"
18588 " Redacted form: plprec(setp, prec)\n"
18589 "\n"
18590 " This function is used in example 29.\n"
18591 "\n"
18592 "\n"
18593 "\n"
18594 "SYNOPSIS:\n"
18595 "\n"
18596 "plprec(setp, prec)\n"
18597 "\n"
18598 "ARGUMENTS:\n"
18599 "\n"
18600 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
18601 " automatically determines the number of places to use after the\n"
18602 " decimal point in numeric labels (like those used to label axes).\n"
18603 " If setp is 1 then prec sets the number of places.\n"
18604 "\n"
18605 " prec (PLINT, input) : The number of characters to draw after the\n"
18606 " decimal point in numeric labels.\n"
18607 "\n"
18608 ""},
18609 { "plpsty", _wrap_plpsty, METH_O, "\n"
18610 "Select area fill pattern\n"
18611 "\n"
18612 "DESCRIPTION:\n"
18613 "\n"
18614 " If\n"
18615 " patt is zero or less use either a hardware solid fill if the drivers\n"
18616 " have that capability (virtually all do) or fall back to a software\n"
18617 " emulation of a solid fill using the eighth area line fill pattern. If\n"
18618 " 0 <\n"
18619 " patt <= 8, then select one of eight predefined area line fill patterns\n"
18620 " to use (see plpat if you desire other patterns).\n"
18621 "\n"
18622 " Redacted form: plpsty(patt)\n"
18623 "\n"
18624 " This function is used in examples 12, 13, 15, 16, and 25.\n"
18625 "\n"
18626 "\n"
18627 "\n"
18628 "SYNOPSIS:\n"
18629 "\n"
18630 "plpsty(patt)\n"
18631 "\n"
18632 "ARGUMENTS:\n"
18633 "\n"
18634 " patt (PLINT, input) : The desired pattern index. If\n"
18635 " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
18636 " above) used. For\n"
18637 " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
18638 " line fill capability itself (most deliberately do not so that line\n"
18639 " fill patterns look identical for those drivers), the patterns\n"
18640 " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
18641 " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
18642 " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
18643 " (8) lines at both 45 degrees and -45 degrees.\n"
18644 "\n"
18645 ""},
18646 { "plptex", _wrap_plptex, METH_VARARGS, "\n"
18647 "Write text inside the viewport\n"
18648 "\n"
18649 "DESCRIPTION:\n"
18650 "\n"
18651 " Writes text at a specified position and inclination within the\n"
18652 " viewport. Text is clipped at the viewport boundaries. The reference\n"
18653 " point of a string lies along a line passing through the string at half\n"
18654 " the height of a capital letter. The position of the reference point\n"
18655 " along this line is determined by just, the reference point is placed\n"
18656 " at world coordinates (\n"
18657 " x,\n"
18658 " y) within the viewport. The inclination of the string is specified\n"
18659 " in terms of differences of world coordinates making it easy to write\n"
18660 " text parallel to a line in a graph.\n"
18661 "\n"
18662 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
18663 "\n"
18664 " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
18665 "\n"
18666 "\n"
18667 "\n"
18668 "SYNOPSIS:\n"
18669 "\n"
18670 "plptex(x, y, dx, dy, just, text)\n"
18671 "\n"
18672 "ARGUMENTS:\n"
18673 "\n"
18674 " x (PLFLT, input) : x coordinate of reference point of string.\n"
18675 "\n"
18676 " y (PLFLT, input) : y coordinate of reference point of string.\n"
18677 "\n"
18678 " dx (PLFLT, input) : Together with dy, this specifies the\n"
18679 " inclination of the string. The baseline of the string is parallel\n"
18680 " to a line joining (\n"
18681 " x,\n"
18682 " y) to (\n"
18683 " x+\n"
18684 " dx,\n"
18685 " y+\n"
18686 " dy) .\n"
18687 "\n"
18688 " dy (PLFLT, input) : Together with dx, this specifies the\n"
18689 " inclination of the string.\n"
18690 "\n"
18691 " just (PLFLT, input) : Specifies the position of the string relative\n"
18692 " to its reference point. If just=0. , the reference point is at\n"
18693 " the left and if just=1. , it is at the right of the string. Other\n"
18694 " values of just give intermediate justifications.\n"
18695 "\n"
18696 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18697 " written out.\n"
18698 "\n"
18699 ""},
18700 { "plptex3", _wrap_plptex3, METH_VARARGS, "\n"
18701 "Write text inside the viewport of a 3D plot\n"
18702 "\n"
18703 "DESCRIPTION:\n"
18704 "\n"
18705 " Writes text at a specified position and inclination and with a\n"
18706 " specified shear within the viewport. Text is clipped at the viewport\n"
18707 " boundaries. The reference point of a string lies along a line passing\n"
18708 " through the string at half the height of a capital letter. The\n"
18709 " position of the reference point along this line is determined by just,\n"
18710 " and the reference point is placed at world coordinates (\n"
18711 " wx,\n"
18712 " wy,\n"
18713 " wz) within the viewport. The inclination and shear of the string is\n"
18714 " specified in terms of differences of world coordinates making it easy\n"
18715 " to write text parallel to a line in a graph.\n"
18716 "\n"
18717 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
18718 "\n"
18719 " This function is used in example 28.\n"
18720 "\n"
18721 "\n"
18722 "\n"
18723 "SYNOPSIS:\n"
18724 "\n"
18725 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
18726 "\n"
18727 "ARGUMENTS:\n"
18728 "\n"
18729 " wx (PLFLT, input) : x world coordinate of reference point of\n"
18730 " string.\n"
18731 "\n"
18732 " wy (PLFLT, input) : y world coordinate of reference point of\n"
18733 " string.\n"
18734 "\n"
18735 " wz (PLFLT, input) : z world coordinate of reference point of\n"
18736 " string.\n"
18737 "\n"
18738 " dx (PLFLT, input) : Together with dy and\n"
18739 " dz , this specifies the inclination of the string. The baseline of\n"
18740 " the string is parallel to a line joining (\n"
18741 " x,\n"
18742 " y,\n"
18743 " z) to (\n"
18744 " x+\n"
18745 " dx,\n"
18746 " y+\n"
18747 " dy,\n"
18748 " z+\n"
18749 " dz) .\n"
18750 "\n"
18751 " dy (PLFLT, input) : Together with dx and\n"
18752 " dz, this specifies the inclination of the string.\n"
18753 "\n"
18754 " dz (PLFLT, input) : Together with dx and\n"
18755 " dy, this specifies the inclination of the string.\n"
18756 "\n"
18757 " sx (PLFLT, input) : Together with sy and\n"
18758 " sz , this specifies the shear of the string. The string is sheared so\n"
18759 " that the characters are vertically parallel to a line joining (\n"
18760 " x,\n"
18761 " y,\n"
18762 " z) to (\n"
18763 " x+\n"
18764 " sx,\n"
18765 " y+\n"
18766 " sy,\n"
18767 " z+\n"
18768 " sz) . If sx =\n"
18769 " sy =\n"
18770 " sz = 0.) then the text is not sheared.\n"
18771 "\n"
18772 " sy (PLFLT, input) : Together with sx and\n"
18773 " sz, this specifies shear of the string.\n"
18774 "\n"
18775 " sz (PLFLT, input) : Together with sx and\n"
18776 " sy, this specifies shear of the string.\n"
18777 "\n"
18778 " just (PLFLT, input) : Specifies the position of the string relative\n"
18779 " to its reference point. If just=0. , the reference point is at\n"
18780 " the left and if just=1. , it is at the right of the string. Other\n"
18781 " values of just give intermediate justifications.\n"
18782 "\n"
18783 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18784 " written out.\n"
18785 "\n"
18786 ""},
18787 { "plrandd", _wrap_plrandd, METH_NOARGS, "\n"
18788 "Random number generator returning a real random number in the range [0,1]\n"
18789 "\n"
18790 "DESCRIPTION:\n"
18791 "\n"
18792 " Random number generator returning a real random number in the range\n"
18793 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
18794 " / compilers provide their own random number generator, and so this is\n"
18795 " provided purely for convenience and to give a consistent random number\n"
18796 " generator across all languages supported by PLplot. This is\n"
18797 " particularly useful for comparing results from the test suite of\n"
18798 " examples.\n"
18799 "\n"
18800 " Redacted form: plrandd()\n"
18801 "\n"
18802 " This function is used in examples 17 and 21.\n"
18803 "\n"
18804 "\n"
18805 "\n"
18806 "SYNOPSIS:\n"
18807 "\n"
18808 "plrandd()\n"
18809 "\n"
18810 ""},
18811 { "plreplot", _wrap_plreplot, METH_NOARGS, "\n"
18812 "Replays contents of plot buffer to current device/file\n"
18813 "\n"
18814 "DESCRIPTION:\n"
18815 "\n"
18816 " Replays contents of plot buffer to current device/file.\n"
18817 "\n"
18818 " Redacted form: plreplot()\n"
18819 "\n"
18820 " This function is used in example 1,20.\n"
18821 "\n"
18822 "\n"
18823 "\n"
18824 "SYNOPSIS:\n"
18825 "\n"
18826 "plreplot()\n"
18827 "\n"
18828 ""},
18829 { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, "\n"
18830 "Convert RGB color to HLS\n"
18831 "\n"
18832 "DESCRIPTION:\n"
18833 "\n"
18834 " Convert RGB color coordinates to HLS\n"
18835 "\n"
18836 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18837 "\n"
18838 "\n"
18839 " This function is used in example 2.\n"
18840 "\n"
18841 "\n"
18842 "\n"
18843 "SYNOPSIS:\n"
18844 "\n"
18845 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
18846 "\n"
18847 "ARGUMENTS:\n"
18848 "\n"
18849 " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
18850 "\n"
18851 " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
18852 "\n"
18853 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
18854 "\n"
18855 " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
18856 " degrees (0.0-360.0) on the color cylinder.\n"
18857 "\n"
18858 " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
18859 " expressed as a fraction (0.0-1.0) of the axis of the color\n"
18860 " cylinder.\n"
18861 "\n"
18862 " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
18863 " expressed as a fraction (0.0-1.0) of the radius of the color\n"
18864 " cylinder.\n"
18865 "\n"
18866 ""},
18867 { "plschr", _wrap_plschr, METH_VARARGS, "\n"
18868 "Set character size\n"
18869 "\n"
18870 "DESCRIPTION:\n"
18871 "\n"
18872 " This sets up the size of all subsequent characters drawn. The actual\n"
18873 " height of a character is the product of the default character size and\n"
18874 " a scaling factor.\n"
18875 "\n"
18876 " Redacted form: plschr(def, scale)\n"
18877 "\n"
18878 " This function is used in examples 2, 13, 23, and 24.\n"
18879 "\n"
18880 "\n"
18881 "\n"
18882 "SYNOPSIS:\n"
18883 "\n"
18884 "plschr(def, scale)\n"
18885 "\n"
18886 "ARGUMENTS:\n"
18887 "\n"
18888 " def (PLFLT, input) : The default height of a character in\n"
18889 " millimeters, should be set to zero if the default height is to\n"
18890 " remain unchanged. For rasterized drivers the dx and dy values\n"
18891 " specified in plspage are used to convert from mm to pixels (note\n"
18892 " the different unit systems used). This dpi aware scaling is not\n"
18893 " implemented for all drivers yet.\n"
18894 "\n"
18895 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
18896 " actual character height.\n"
18897 "\n"
18898 ""},
18899 { "plscmap0", _wrap_plscmap0, METH_VARARGS, "\n"
18900 "Set cmap0 colors by 8-bit RGB values\n"
18901 "\n"
18902 "DESCRIPTION:\n"
18903 "\n"
18904 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
18905 " documentation). This sets the entire color map -- only as many colors\n"
18906 " as specified will be allocated.\n"
18907 "\n"
18908 " Redacted form: plscmap0(r, g, b)\n"
18909 "\n"
18910 " This function is used in examples 2 and 24.\n"
18911 "\n"
18912 "\n"
18913 "\n"
18914 "SYNOPSIS:\n"
18915 "\n"
18916 "plscmap0(r, g, b, ncol0)\n"
18917 "\n"
18918 "ARGUMENTS:\n"
18919 "\n"
18920 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18921 " integers (0-255) representing the degree of red in the color.\n"
18922 "\n"
18923 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18924 " integers (0-255) representing the degree of green in the color.\n"
18925 "\n"
18926 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18927 " integers (0-255) representing the degree of blue in the color.\n"
18928 "\n"
18929 " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
18930 "\n"
18931 ""},
18932 { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, "\n"
18933 "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
18934 "\n"
18935 "DESCRIPTION:\n"
18936 "\n"
18937 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
18938 " and PLFLT alpha transparency value. This sets the entire color map --\n"
18939 " only as many colors as specified will be allocated.\n"
18940 "\n"
18941 " Redacted form: plscmap0a(r, g, b, alpha)\n"
18942 "\n"
18943 " This function is used in examples 30.\n"
18944 "\n"
18945 "\n"
18946 "\n"
18947 "SYNOPSIS:\n"
18948 "\n"
18949 "plscmap0a(r, g, b, alpha, ncol0)\n"
18950 "\n"
18951 "ARGUMENTS:\n"
18952 "\n"
18953 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18954 " integers (0-255) representing the degree of red in the color.\n"
18955 "\n"
18956 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18957 " integers (0-255) representing the degree of green in the color.\n"
18958 "\n"
18959 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
18960 " integers (0-255) representing the degree of blue in the color.\n"
18961 "\n"
18962 " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
18963 " representing the alpha transparency of the color.\n"
18964 "\n"
18965 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
18966 " vectors.\n"
18967 "\n"
18968 ""},
18969 { "plscmap0n", _wrap_plscmap0n, METH_O, "\n"
18970 "Set number of colors in cmap0\n"
18971 "\n"
18972 "DESCRIPTION:\n"
18973 "\n"
18974 " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
18975 " (or reallocate) cmap0, and fill with default values for those colors\n"
18976 " not previously allocated. The first 16 default colors are given in\n"
18977 " the plcol0 documentation. For larger indices the default color is\n"
18978 " red.\n"
18979 "\n"
18980 " The drivers are not guaranteed to support more than 16 colors.\n"
18981 "\n"
18982 " Redacted form: plscmap0n(ncol0)\n"
18983 "\n"
18984 " This function is used in examples 15, 16, and 24.\n"
18985 "\n"
18986 "\n"
18987 "\n"
18988 "SYNOPSIS:\n"
18989 "\n"
18990 "plscmap0n(ncol0)\n"
18991 "\n"
18992 "ARGUMENTS:\n"
18993 "\n"
18994 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
18995 " the cmap0 palette. If this number is zero or less, then the value\n"
18996 " from the previous call to plscmap0n is used and if there is no\n"
18997 " previous call, then a default value is used.\n"
18998 "\n"
18999 ""},
19000 { "plscmap1", _wrap_plscmap1, METH_VARARGS, "\n"
19001 "Set opaque RGB cmap1 colors values\n"
19002 "\n"
19003 "DESCRIPTION:\n"
19004 "\n"
19005 " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19006 " vector values. This function also sets the number of cmap1 colors.\n"
19007 " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19008 " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19009 " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19010 " to\n"
19011 " ncol1-1. So in order for this continuous color model to work\n"
19012 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19013 " that these RGB vectors are continuous functions of their integer\n"
19014 " indices.\n"
19015 "\n"
19016 " Redacted form: plscmap1(r, g, b)\n"
19017 "\n"
19018 " This function is used in example 31.\n"
19019 "\n"
19020 "\n"
19021 "\n"
19022 "SYNOPSIS:\n"
19023 "\n"
19024 "plscmap1(r, g, b, ncol1)\n"
19025 "\n"
19026 "ARGUMENTS:\n"
19027 "\n"
19028 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19029 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19030 " color as a continuous function of the integer index of the vector.\n"
19031 "\n"
19032 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19033 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19034 " color as a continuous function of the integer index of the vector.\n"
19035 "\n"
19036 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19037 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19038 " color as a continuous function of the integer index of the vector.\n"
19039 "\n"
19040 " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19041 "\n"
19042 ""},
19043 { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, "\n"
19044 "Set semitransparent cmap1 RGBA colors.\n"
19045 "\n"
19046 "DESCRIPTION:\n"
19047 "\n"
19048 " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19049 " RGBA vector values. This function also sets the number of cmap1\n"
19050 " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19051 " floating-point index in the range from 0.0-1.0 which is linearly\n"
19052 " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19053 " vectors in the range from 0 to\n"
19054 " ncol1-1. So in order for this continuous color model to work\n"
19055 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19056 " that these RGBA vectors are continuous functions of their integer\n"
19057 " indices.\n"
19058 "\n"
19059 " Redacted form: plscmap1a(r, g, b, alpha)\n"
19060 "\n"
19061 " This function is used in example 31.\n"
19062 "\n"
19063 "\n"
19064 "\n"
19065 "SYNOPSIS:\n"
19066 "\n"
19067 "plscmap1a(r, g, b, alpha, ncol1)\n"
19068 "\n"
19069 "ARGUMENTS:\n"
19070 "\n"
19071 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19072 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19073 " color as a continuous function of the integer index of the vector.\n"
19074 "\n"
19075 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19076 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19077 " color as a continuous function of the integer index of the vector.\n"
19078 "\n"
19079 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19080 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19081 " color as a continuous function of the integer index of the vector.\n"
19082 "\n"
19083 " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19084 " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19085 " completely transparent and 1.0 corresponds to completely opaque)\n"
19086 " the alpha transparency of the color as a continuous function of\n"
19087 " the integer index of the vector.\n"
19088 "\n"
19089 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19090 " vectors.\n"
19091 "\n"
19092 ""},
19093 { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, "\n"
19094 "Set cmap1 colors using a piece-wise linear relationship\n"
19095 "\n"
19096 "DESCRIPTION:\n"
19097 "\n"
19098 " Set cmap1 colors using a piece-wise linear relationship between the\n"
19099 " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19100 " (see the PLplot documentation). May be called at any time.\n"
19101 "\n"
19102 " The idea here is to specify a number of control points that define the\n"
19103 " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19104 " these points, linear interpolation is used which gives a smooth\n"
19105 " variation of color with intensity index. Any number of control points\n"
19106 " may be specified, located at arbitrary positions, although typically 2\n"
19107 " - 4 are enough. Another way of stating this is that we are traversing\n"
19108 " a given number of lines through HLS or RGB space as we move through\n"
19109 " cmap1 intensity indices. The control points at the minimum and\n"
19110 " maximum position (0 and 1) must always be specified. By adding more\n"
19111 " control points you can get more variation. One good technique for\n"
19112 " plotting functions that vary about some expected average is to use an\n"
19113 " additional 2 control points in the center (position ~= 0.5) that are\n"
19114 " the same lightness as the background (typically white for paper\n"
19115 " output, black for crt), and same hue as the boundary control points.\n"
19116 " This allows the highs and lows to be very easily distinguished.\n"
19117 "\n"
19118 " Each control point must specify the cmap1 intensity index and the\n"
19119 " associated three coordinates in HLS or RGB space. The first point\n"
19120 " must correspond to position = 0, and the last to position = 1.\n"
19121 "\n"
19122 " If RGB colors are provided then the interpolation takes place in RGB\n"
19123 " space and is trivial. However if HLS colors are provided then, because\n"
19124 " of the circular nature of the color wheel for the hue coordinate, the\n"
19125 " interpolation could be performed in either direction around the color\n"
19126 " wheel. The default behaviour is for the hue to be linearly\n"
19127 " interpolated ignoring this circular property of hue. So for example,\n"
19128 " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19129 " green and cyan. If instead you wish to interpolate the other way\n"
19130 " around the color wheel you have two options. You may provide hues\n"
19131 " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19132 " for red the interpolation will proceed via magenta. Alternatively you\n"
19133 " can utilise the alt_hue_path variable to reverse the direction of\n"
19134 " interpolation if you need to provide hues within the [0-360) range.\n"
19135 "\n"
19136 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19137 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19138 " -120]falsegreen-yellow-red-magenta-blue[240\n"
19139 " 480]falseblue-magenta-red-yellow-green[120\n"
19140 " 240]truegreen-yellow-red-magenta-blue[240\n"
19141 " 120]trueblue-magenta-red-yellow-green\n"
19142 "\n"
19143 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19144 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19145 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19146 "\n"
19147 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19148 " alt_hue_path)\n"
19149 "\n"
19150 " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19151 "\n"
19152 "\n"
19153 "\n"
19154 "SYNOPSIS:\n"
19155 "\n"
19156 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19157 "\n"
19158 "ARGUMENTS:\n"
19159 "\n"
19160 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19161 "\n"
19162 " npts (PLINT, input) : number of control points\n"
19163 "\n"
19164 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19165 " intensity index (0.0-1.0) in ascending order for each control\n"
19166 " point.\n"
19167 "\n"
19168 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19169 " coordinate (H or R) for each control point.\n"
19170 "\n"
19171 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19172 " coordinate (L or G) for each control point.\n"
19173 "\n"
19174 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19175 " coordinate (S or B) for each control point.\n"
19176 "\n"
19177 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19178 " npts - 1 elements), each containing either true to use the reversed\n"
19179 " HLS interpolation or false to use the regular HLS interpolation.\n"
19180 " (alt_hue_path[i] refers to the interpolation interval between the\n"
19181 " i and i + 1 control points). This parameter is not used for RGB\n"
19182 " colors (\n"
19183 " itype = true).\n"
19184 "\n"
19185 ""},
19186 { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, "\n"
19187 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19188 "\n"
19189 "DESCRIPTION:\n"
19190 "\n"
19191 " This is a variant of plscmap1l that supports alpha channel\n"
19192 " transparency. It sets cmap1 colors using a piece-wise linear\n"
19193 " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19194 " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19195 " transparency value (0.0-1.0). It may be called at any time.\n"
19196 "\n"
19197 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19198 " alpha, alt_hue_path)\n"
19199 "\n"
19200 " This function is used in example 30.\n"
19201 "\n"
19202 "\n"
19203 "\n"
19204 "SYNOPSIS:\n"
19205 "\n"
19206 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19207 "\n"
19208 "ARGUMENTS:\n"
19209 "\n"
19210 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19211 "\n"
19212 " npts (PLINT, input) : number of control points.\n"
19213 "\n"
19214 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19215 " intensity index (0.0-1.0) in ascending order for each control\n"
19216 " point.\n"
19217 "\n"
19218 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19219 " coordinate (H or R) for each control point.\n"
19220 "\n"
19221 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19222 " coordinate (L or G) for each control point.\n"
19223 "\n"
19224 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19225 " coordinate (S or B) for each control point.\n"
19226 "\n"
19227 " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19228 " transparency value (0.0-1.0) for each control point.\n"
19229 "\n"
19230 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19231 " npts - 1 elements) containing the alternative interpolation method\n"
19232 " Boolean value for each control point interval. (alt_hue_path[i]\n"
19233 " refers to the interpolation interval between the i and i + 1\n"
19234 " control points).\n"
19235 "\n"
19236 ""},
19237 { "plscmap1n", _wrap_plscmap1n, METH_O, "\n"
19238 "Set number of colors in cmap1\n"
19239 "\n"
19240 "DESCRIPTION:\n"
19241 "\n"
19242 " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19243 " values if this is the first allocation (see the PLplot documentation).\n"
19244 "\n"
19245 " Redacted form: plscmap1n(ncol1)\n"
19246 "\n"
19247 " This function is used in examples 8, 11, 20, and 21.\n"
19248 "\n"
19249 "\n"
19250 "\n"
19251 "SYNOPSIS:\n"
19252 "\n"
19253 "plscmap1n(ncol1)\n"
19254 "\n"
19255 "ARGUMENTS:\n"
19256 "\n"
19257 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19258 " the cmap1 palette. If this number is zero or less, then the value\n"
19259 " from the previous call to plscmap1n is used and if there is no\n"
19260 " previous call, then a default value is used.\n"
19261 "\n"
19262 ""},
19263 { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, "\n"
19264 "Set the cmap1 argument range for continuous color plots\n"
19265 "\n"
19266 "DESCRIPTION:\n"
19267 "\n"
19268 " Set the cmap1 argument range for continuous color plots that\n"
19269 " corresponds to the range of data values. The maximum range\n"
19270 " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
19271 " the cmap1 argument range that is specified with this routine, the\n"
19272 " smaller the subset of the cmap1 color palette that is used to\n"
19273 " represent the continuous data being plotted. If\n"
19274 " min_color is greater than\n"
19275 " max_color or\n"
19276 " max_color is greater than 1.0 or\n"
19277 " min_color is less than 0.0 then no change is made to the cmap1\n"
19278 " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
19279 "\n"
19280 " Redacted form: plscmap1_range(min_color, max_color)\n"
19281 "\n"
19282 " This function is currently used in example 33.\n"
19283 "\n"
19284 "\n"
19285 "\n"
19286 "SYNOPSIS:\n"
19287 "\n"
19288 "plscmap1_range(min_color, max_color)\n"
19289 "\n"
19290 "ARGUMENTS:\n"
19291 "\n"
19292 " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
19293 " than 0.0, then 0.0 is used instead.\n"
19294 "\n"
19295 " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
19296 " than 1.0, then 1.0 is used instead.\n"
19297 "\n"
19298 ""},
19299 { "plgcmap1_range", _wrap_plgcmap1_range, METH_NOARGS, "\n"
19300 "Get the cmap1 argument range for continuous color plots\n"
19301 "\n"
19302 "DESCRIPTION:\n"
19303 "\n"
19304 " Get the cmap1 argument range for continuous color plots. (Use\n"
19305 " plscmap1_range to set the cmap1 argument range.)\n"
19306 "\n"
19307 " Redacted form: plgcmap1_range(min_color, max_color)\n"
19308 "\n"
19309 " This function is currently not used in any example.\n"
19310 "\n"
19311 "\n"
19312 "\n"
19313 "SYNOPSIS:\n"
19314 "\n"
19315 "plgcmap1_range(min_color, max_color)\n"
19316 "\n"
19317 "ARGUMENTS:\n"
19318 "\n"
19319 " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19320 " minimum cmap1 argument.\n"
19321 "\n"
19322 " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19323 " maximum cmap1 argument.\n"
19324 "\n"
19325 ""},
19326 { "plscol0", _wrap_plscol0, METH_VARARGS, "\n"
19327 "Set 8-bit RGB values for given cmap0 color index\n"
19328 "\n"
19329 "DESCRIPTION:\n"
19330 "\n"
19331 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
19332 " index. Overwrites the previous color value for the given index and,\n"
19333 " thus, does not result in any additional allocation of space for\n"
19334 " colors.\n"
19335 "\n"
19336 " Redacted form: plscol0(icol0, r, g, b)\n"
19337 "\n"
19338 " This function is used in any example 31.\n"
19339 "\n"
19340 "\n"
19341 "\n"
19342 "SYNOPSIS:\n"
19343 "\n"
19344 "plscol0(icol0, r, g, b)\n"
19345 "\n"
19346 "ARGUMENTS:\n"
19347 "\n"
19348 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19349 " number of colors (which is set by default, by plscmap0n, or even\n"
19350 " by plscmap0).\n"
19351 "\n"
19352 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19353 " degree of red in the color.\n"
19354 "\n"
19355 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19356 " degree of green in the color.\n"
19357 "\n"
19358 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19359 " degree of blue in the color.\n"
19360 "\n"
19361 ""},
19362 { "plscol0a", _wrap_plscol0a, METH_VARARGS, "\n"
19363 "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
19364 "\n"
19365 "DESCRIPTION:\n"
19366 "\n"
19367 " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
19368 " (see the PLplot documentation) index. Overwrites the previous color\n"
19369 " value for the given index and, thus, does not result in any additional\n"
19370 " allocation of space for colors.\n"
19371 "\n"
19372 " This function is used in example 30.\n"
19373 "\n"
19374 "\n"
19375 "\n"
19376 "SYNOPSIS:\n"
19377 "\n"
19378 "plscol0a(icol0, r, g, b, alpha)\n"
19379 "\n"
19380 "ARGUMENTS:\n"
19381 "\n"
19382 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19383 " number of colors (which is set by default, by plscmap0n, or even\n"
19384 " by plscmap0).\n"
19385 "\n"
19386 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19387 " degree of red in the color.\n"
19388 "\n"
19389 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19390 " degree of green in the color.\n"
19391 "\n"
19392 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19393 " degree of blue in the color.\n"
19394 "\n"
19395 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
19396 " (0.0-1.0).\n"
19397 "\n"
19398 ""},
19399 { "plscolbg", _wrap_plscolbg, METH_VARARGS, "\n"
19400 "Set the background color by 8-bit RGB value\n"
19401 "\n"
19402 "DESCRIPTION:\n"
19403 "\n"
19404 " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
19405 " the PLplot documentation).\n"
19406 "\n"
19407 " Redacted form: plscolbg(r, g, b)\n"
19408 "\n"
19409 " This function is used in examples 15 and 31.\n"
19410 "\n"
19411 "\n"
19412 "\n"
19413 "SYNOPSIS:\n"
19414 "\n"
19415 "plscolbg(r, g, b)\n"
19416 "\n"
19417 "ARGUMENTS:\n"
19418 "\n"
19419 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19420 " degree of red in the color.\n"
19421 "\n"
19422 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19423 " degree of green in the color.\n"
19424 "\n"
19425 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19426 " degree of blue in the color.\n"
19427 "\n"
19428 ""},
19429 { "plscolbga", _wrap_plscolbga, METH_VARARGS, "\n"
19430 "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
19431 "\n"
19432 "DESCRIPTION:\n"
19433 "\n"
19434 " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
19435 " PLFLT alpha transparency value (see the PLplot documentation).\n"
19436 "\n"
19437 " This function is used in example 31.\n"
19438 "\n"
19439 "\n"
19440 "\n"
19441 "SYNOPSIS:\n"
19442 "\n"
19443 "plscolbga(r, g, b, alpha)\n"
19444 "\n"
19445 "ARGUMENTS:\n"
19446 "\n"
19447 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19448 " degree of red in the color.\n"
19449 "\n"
19450 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19451 " degree of green in the color.\n"
19452 "\n"
19453 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19454 " degree of blue in the color.\n"
19455 "\n"
19456 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
19457 " (0.0-1.0).\n"
19458 "\n"
19459 ""},
19460 { "plscolor", _wrap_plscolor, METH_O, "\n"
19461 "Used to globally turn color output on/off\n"
19462 "\n"
19463 "DESCRIPTION:\n"
19464 "\n"
19465 " Used to globally turn color output on/off for those drivers/devices\n"
19466 " that support it.\n"
19467 "\n"
19468 " Redacted form: plscolor(color)\n"
19469 "\n"
19470 " This function is used in example 31.\n"
19471 "\n"
19472 "\n"
19473 "\n"
19474 "SYNOPSIS:\n"
19475 "\n"
19476 "plscolor(color)\n"
19477 "\n"
19478 "ARGUMENTS:\n"
19479 "\n"
19480 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
19481 " turned off. If non-zero, color is turned on.\n"
19482 "\n"
19483 ""},
19484 { "plscompression", _wrap_plscompression, METH_O, "\n"
19485 "Set device-compression level\n"
19486 "\n"
19487 "DESCRIPTION:\n"
19488 "\n"
19489 " Set device-compression level. Only used for drivers that provide\n"
19490 " compression. This function, if used, should be invoked before a call\n"
19491 " to plinit.\n"
19492 "\n"
19493 " Redacted form: plscompression(compression)\n"
19494 "\n"
19495 " This function is used in example 31.\n"
19496 "\n"
19497 "\n"
19498 "\n"
19499 "SYNOPSIS:\n"
19500 "\n"
19501 "plscompression(compression)\n"
19502 "\n"
19503 "ARGUMENTS:\n"
19504 "\n"
19505 " compression (PLINT, input) : The desired compression level. This is\n"
19506 " a device-dependent value. Currently only the jpeg and png devices\n"
19507 " use these values. For jpeg value is the jpeg quality which should\n"
19508 " normally be in the range 0-95. Higher values denote higher quality\n"
19509 " and hence larger image sizes. For png values are in the range -1\n"
19510 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
19511 " A value of -1 denotes the default zlib compression level. Values\n"
19512 " in the range 10-99 are divided by 10 and then used as the zlib\n"
19513 " compression level. Higher compression levels correspond to greater\n"
19514 " compression and small file sizes at the expense of more\n"
19515 " computation.\n"
19516 "\n"
19517 ""},
19518 { "plsdev", _wrap_plsdev, METH_O, "\n"
19519 "Set the device (keyword) name\n"
19520 "\n"
19521 "DESCRIPTION:\n"
19522 "\n"
19523 " Set the device (keyword) name.\n"
19524 "\n"
19525 " Redacted form: plsdev(devname)\n"
19526 "\n"
19527 " This function is used in examples 1, 14, and 20.\n"
19528 "\n"
19529 "\n"
19530 "\n"
19531 "SYNOPSIS:\n"
19532 "\n"
19533 "plsdev(devname)\n"
19534 "\n"
19535 "ARGUMENTS:\n"
19536 "\n"
19537 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
19538 " containing the device name keyword of the required output device.\n"
19539 " If\n"
19540 " devname is NULL or if the first character of the string is a ``?'',\n"
19541 " the normal (prompted) start up is used.\n"
19542 "\n"
19543 ""},
19544 { "plsdidev", _wrap_plsdidev, METH_VARARGS, "\n"
19545 "Set parameters that define current device-space window\n"
19546 "\n"
19547 "DESCRIPTION:\n"
19548 "\n"
19549 " Set relative margin width, aspect ratio, and relative justification\n"
19550 " that define current device-space window. If you want to just use the\n"
19551 " previous value for any of these, just pass in the magic value\n"
19552 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
19553 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
19554 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
19555 " to a device-specific value.\n"
19556 "\n"
19557 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
19558 "\n"
19559 " This function is used in example 31.\n"
19560 "\n"
19561 "\n"
19562 "\n"
19563 "SYNOPSIS:\n"
19564 "\n"
19565 "plsdidev(mar, aspect, jx, jy)\n"
19566 "\n"
19567 "ARGUMENTS:\n"
19568 "\n"
19569 " mar (PLFLT, input) : Relative margin width.\n"
19570 "\n"
19571 " aspect (PLFLT, input) : Aspect ratio.\n"
19572 "\n"
19573 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
19574 " the range -0.5 to 0.5.\n"
19575 "\n"
19576 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
19577 " the range -0.5 to 0.5.\n"
19578 "\n"
19579 ""},
19580 { "plsdimap", _wrap_plsdimap, METH_VARARGS, "\n"
19581 "Set up transformation from metafile coordinates\n"
19582 "\n"
19583 "DESCRIPTION:\n"
19584 "\n"
19585 " Set up transformation from metafile coordinates. The size of the plot\n"
19586 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
19587 " general-purpose facility just yet (not sure why the user would need\n"
19588 " it, for one).\n"
19589 "\n"
19590 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
19591 " dimypmm)\n"
19592 "\n"
19593 " This function is not used in any examples.\n"
19594 "\n"
19595 "\n"
19596 "\n"
19597 "SYNOPSIS:\n"
19598 "\n"
19599 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
19600 "\n"
19601 "ARGUMENTS:\n"
19602 "\n"
19603 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
19604 "\n"
19605 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
19606 "\n"
19607 " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
19608 "\n"
19609 " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
19610 "\n"
19611 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
19612 "\n"
19613 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
19614 "\n"
19615 ""},
19616 { "plsdiori", _wrap_plsdiori, METH_O, "\n"
19617 "Set plot orientation\n"
19618 "\n"
19619 "DESCRIPTION:\n"
19620 "\n"
19621 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
19622 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
19623 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
19624 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
19625 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
19626 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
19627 " not called the default value of rot is 0.\n"
19628 "\n"
19629 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
19630 " probably want to change the aspect ratio to a value suitable for the\n"
19631 " plot orientation using a call to plsdidev or the command-line options\n"
19632 " -a or -freeaspect. For more documentation of those options see the\n"
19633 " PLplot documentation. Such command-line options can be set internally\n"
19634 " using plsetopt or set directly using the command line and parsed using\n"
19635 " a call to plparseopts.\n"
19636 "\n"
19637 " Redacted form: plsdiori(rot)\n"
19638 "\n"
19639 " This function is not used in any examples.\n"
19640 "\n"
19641 "\n"
19642 "\n"
19643 "SYNOPSIS:\n"
19644 "\n"
19645 "plsdiori(rot)\n"
19646 "\n"
19647 "ARGUMENTS:\n"
19648 "\n"
19649 " rot (PLFLT, input) : Plot orientation parameter.\n"
19650 "\n"
19651 ""},
19652 { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, "\n"
19653 "Set parameters that define current plot-space window\n"
19654 "\n"
19655 "DESCRIPTION:\n"
19656 "\n"
19657 " Set relative minima and maxima that define the current plot-space\n"
19658 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
19659 " xmax, and ymax are 0., 0., 1., and 1.\n"
19660 "\n"
19661 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
19662 "\n"
19663 " This function is used in example 31.\n"
19664 "\n"
19665 "\n"
19666 "\n"
19667 "SYNOPSIS:\n"
19668 "\n"
19669 "plsdiplt(xmin, ymin, xmax, ymax)\n"
19670 "\n"
19671 "ARGUMENTS:\n"
19672 "\n"
19673 " xmin (PLFLT, input) : Relative minimum in x.\n"
19674 "\n"
19675 " ymin (PLFLT, input) : Relative minimum in y.\n"
19676 "\n"
19677 " xmax (PLFLT, input) : Relative maximum in x.\n"
19678 "\n"
19679 " ymax (PLFLT, input) : Relative maximum in y.\n"
19680 "\n"
19681 ""},
19682 { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, "\n"
19683 "Set parameters incrementally (zoom mode) that define current plot-space window\n"
19684 "\n"
19685 "DESCRIPTION:\n"
19686 "\n"
19687 " Set relative minima and maxima incrementally (zoom mode) that define\n"
19688 " the current plot-space window. This function has the same effect as\n"
19689 " plsdiplt if that function has not been previously called. Otherwise,\n"
19690 " this function implements zoom mode using the transformation min_used =\n"
19691 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
19692 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
19693 " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
19694 "\n"
19695 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
19696 "\n"
19697 " This function is used in example 31.\n"
19698 "\n"
19699 "\n"
19700 "\n"
19701 "SYNOPSIS:\n"
19702 "\n"
19703 "plsdiplz(xmin, ymin, xmax, ymax)\n"
19704 "\n"
19705 "ARGUMENTS:\n"
19706 "\n"
19707 " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
19708 "\n"
19709 " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
19710 "\n"
19711 " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
19712 "\n"
19713 " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
19714 "\n"
19715 ""},
19716 { "plseed", _wrap_plseed, METH_O, "\n"
19717 "Set seed for internal random number generator.\n"
19718 "\n"
19719 "DESCRIPTION:\n"
19720 "\n"
19721 " Set the seed for the internal random number generator. See plrandd for\n"
19722 " further details.\n"
19723 "\n"
19724 " Redacted form: plseed(seed)\n"
19725 "\n"
19726 " This function is used in example 21.\n"
19727 "\n"
19728 "\n"
19729 "\n"
19730 "SYNOPSIS:\n"
19731 "\n"
19732 "plseed(seed)\n"
19733 "\n"
19734 "ARGUMENTS:\n"
19735 "\n"
19736 " seed (unsigned int, input) : Seed for random number generator.\n"
19737 "\n"
19738 ""},
19739 { "plsesc", _wrap_plsesc, METH_O, "\n"
19740 "Set the escape character for text strings\n"
19741 "\n"
19742 "DESCRIPTION:\n"
19743 "\n"
19744 " Set the escape character for text strings. From C (in contrast to\n"
19745 " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
19746 " characters are allowed to prevent the user from shooting himself in\n"
19747 " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
19748 " use of backslash as a character escape). Here are the allowed escape\n"
19749 " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
19750 " #, ASCII 35\n"
19751 " $, ASCII 36\n"
19752 " %, ASCII 37\n"
19753 " &, ASCII 38\n"
19754 " *, ASCII 42\n"
19755 " @, ASCII 64\n"
19756 " ^, ASCII 94\n"
19757 " ~, ASCII 126\n"
19758 "\n"
19759 "\n"
19760 " Redacted form: General: plsesc(esc)\n"
19761 "\n"
19762 "\n"
19763 " This function is used in example 29.\n"
19764 "\n"
19765 "\n"
19766 "\n"
19767 "SYNOPSIS:\n"
19768 "\n"
19769 "plsesc(esc)\n"
19770 "\n"
19771 "ARGUMENTS:\n"
19772 "\n"
19773 " esc (char, input) : Escape character.\n"
19774 "\n"
19775 ""},
19776 { "plsetopt", _wrap_plsetopt, METH_VARARGS, "\n"
19777 "Set any command-line option\n"
19778 "\n"
19779 "DESCRIPTION:\n"
19780 "\n"
19781 " Set any command-line option internally from a program before it\n"
19782 " invokes plinit. opt is the name of the command-line option and optarg\n"
19783 " is the corresponding command-line option argument.\n"
19784 "\n"
19785 " This function returns 0 on success.\n"
19786 "\n"
19787 " Redacted form: plsetopt(opt, optarg)\n"
19788 "\n"
19789 " This function is used in example 14.\n"
19790 "\n"
19791 "\n"
19792 "\n"
19793 "SYNOPSIS:\n"
19794 "\n"
19795 "PLINT plsetopt(opt, optarg)\n"
19796 "\n"
19797 "ARGUMENTS:\n"
19798 "\n"
19799 " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
19800 " the command-line option.\n"
19801 "\n"
19802 " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
19803 " containing the argument of the command-line option.\n"
19804 "\n"
19805 ""},
19806 { "plsfam", _wrap_plsfam, METH_VARARGS, "\n"
19807 "Set family file parameters\n"
19808 "\n"
19809 "DESCRIPTION:\n"
19810 "\n"
19811 " Sets variables dealing with output file familying. Does nothing if\n"
19812 " familying not supported by the driver. This routine, if used, must be\n"
19813 " called before initializing PLplot. See the PLplot documentation for\n"
19814 " more information.\n"
19815 "\n"
19816 " Redacted form: plsfam(fam, num, bmax)\n"
19817 "\n"
19818 " This function is used in examples 14 and 31.\n"
19819 "\n"
19820 "\n"
19821 "\n"
19822 "SYNOPSIS:\n"
19823 "\n"
19824 "plsfam(fam, num, bmax)\n"
19825 "\n"
19826 "ARGUMENTS:\n"
19827 "\n"
19828 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
19829 " is enabled.\n"
19830 "\n"
19831 " num (PLINT, input) : Current family file number.\n"
19832 "\n"
19833 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
19834 " file.\n"
19835 "\n"
19836 ""},
19837 { "plsfci", _wrap_plsfci, METH_O, "\n"
19838 "Set FCI (font characterization integer)\n"
19839 "\n"
19840 "DESCRIPTION:\n"
19841 "\n"
19842 " Sets font characteristics to be used at the start of the next string\n"
19843 " using the FCI approach. See the PLplot documentation for more\n"
19844 " information. Note, plsfont (which calls plsfci internally) provides a\n"
19845 " more user-friendly API for setting the font characterisitics.\n"
19846 "\n"
19847 " Redacted form: General: plsfci(fci)\n"
19848 "\n"
19849 "\n"
19850 " This function is used in example 23.\n"
19851 "\n"
19852 "\n"
19853 "\n"
19854 "SYNOPSIS:\n"
19855 "\n"
19856 "plsfci(fci)\n"
19857 "\n"
19858 "ARGUMENTS:\n"
19859 "\n"
19860 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
19861 " of FCI.\n"
19862 "\n"
19863 ""},
19864 { "plsfnam", _wrap_plsfnam, METH_O, "\n"
19865 "Set output file name\n"
19866 "\n"
19867 "DESCRIPTION:\n"
19868 "\n"
19869 " Sets the current output file name, if applicable. If the file name\n"
19870 " has not been specified and is required by the driver, the user will be\n"
19871 " prompted for it. If using the X-windows output driver, this sets the\n"
19872 " display name. This routine, if used, must be called before\n"
19873 " initializing PLplot.\n"
19874 "\n"
19875 " Redacted form: plsfnam(fnam)\n"
19876 "\n"
19877 " This function is used in examples 1 and 20.\n"
19878 "\n"
19879 "\n"
19880 "\n"
19881 "SYNOPSIS:\n"
19882 "\n"
19883 "plsfnam(fnam)\n"
19884 "\n"
19885 "ARGUMENTS:\n"
19886 "\n"
19887 " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
19888 " the file name.\n"
19889 "\n"
19890 ""},
19891 { "plsfont", _wrap_plsfont, METH_VARARGS, "\n"
19892 "Set family, style and weight of the current font\n"
19893 "\n"
19894 "DESCRIPTION:\n"
19895 "\n"
19896 " Sets the current font. See the PLplot documentation for more\n"
19897 " information on font selection.\n"
19898 "\n"
19899 " Redacted form: plsfont(family, style, weight)\n"
19900 "\n"
19901 " This function is used in example 23.\n"
19902 "\n"
19903 "\n"
19904 "\n"
19905 "SYNOPSIS:\n"
19906 "\n"
19907 "plsfont(family, style, weight)\n"
19908 "\n"
19909 "ARGUMENTS:\n"
19910 "\n"
19911 " family (PLINT, input) : Font family to select for the current font.\n"
19912 " The available values are given by the PL_FCI_* constants in\n"
19913 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
19914 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
19915 " signifies that the font family should not be altered.\n"
19916 "\n"
19917 " style (PLINT, input) : Font style to select for the current font.\n"
19918 " The available values are given by the PL_FCI_* constants in\n"
19919 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
19920 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
19921 " should not be altered.\n"
19922 "\n"
19923 " weight (PLINT, input) : Font weight to select for the current font.\n"
19924 " The available values are given by the PL_FCI_* constants in\n"
19925 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
19926 " negative value signifies that the font weight should not be\n"
19927 " altered.\n"
19928 "\n"
19929 ""},
19930 { "plshades", _wrap_plshades, METH_VARARGS, "\n"
19931 "Shade regions on the basis of value\n"
19932 "\n"
19933 "DESCRIPTION:\n"
19934 "\n"
19935 " Shade regions on the basis of value. This is the high-level routine\n"
19936 " for making continuous color shaded plots with cmap1 while plshade\n"
19937 " should be used to plot individual shaded regions using either cmap0 or\n"
19938 " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
19939 " our supported languages.\n"
19940 "\n"
19941 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
19942 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
19943 " pltr_data)\n"
19944 "\n"
19945 "\n"
19946 " This function is used in examples 16, 21, and 22.\n"
19947 "\n"
19948 "\n"
19949 "\n"
19950 "SYNOPSIS:\n"
19951 "\n"
19952 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
19953 "\n"
19954 "ARGUMENTS:\n"
19955 "\n"
19956 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
19957 " plot. Should have dimensions of\n"
19958 " nx by\n"
19959 " ny.\n"
19960 "\n"
19961 " nx (PLINT, input) : First dimension of matrix \"a\".\n"
19962 "\n"
19963 " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
19964 "\n"
19965 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
19966 " the region that should be plotted in the shade plot. This\n"
19967 " function accepts x and y coordinates as input arguments and must\n"
19968 " return 1 if the point is to be included in the shade plot and 0\n"
19969 " otherwise. If you want to plot the entire shade plot (the usual\n"
19970 " case), this argument should be set to NULL.\n"
19971 "\n"
19972 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
19973 " pltr below for how these arguments are used (only for the special case\n"
19974 " when the callback function\n"
19975 " pltr is not supplied).\n"
19976 "\n"
19977 " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
19978 " corresponding to the edges of each shaded region that will be\n"
19979 " plotted by this function. To work properly the levels should be\n"
19980 " monotonic.\n"
19981 "\n"
19982 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
19983 " of shade edge values in clevel).\n"
19984 "\n"
19985 " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
19986 " pattern.\n"
19987 "\n"
19988 " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
19989 " contours defining edges of shaded regions. The pen color is only\n"
19990 " temporary set for the contour drawing. Set this value to zero or\n"
19991 " less if no shade edge contours are wanted.\n"
19992 "\n"
19993 " cont_width (PLFLT, input) : Defines line width used for contours\n"
19994 " defining edges of shaded regions. This value may not be honored\n"
19995 " by all drivers. The pen width is only temporary set for the\n"
19996 " contour drawing. Set this value to zero or less if no shade edge\n"
19997 " contours are wanted.\n"
19998 "\n"
19999 " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20000 " region. Use plfill for this purpose.\n"
20001 "\n"
20002 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20003 " map to rectangles after coordinate transformation with pltrl.\n"
20004 " Otherwise, set rectangular to false. If rectangular is set to\n"
20005 " true, plshade tries to save time by filling large rectangles.\n"
20006 " This optimization fails if the coordinate transformation distorts\n"
20007 " the shape of rectangles. For example a plot in polar coordinates\n"
20008 " has to have rectangular set to false.\n"
20009 "\n"
20010 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20011 " defines the transformation between the zero-based indices of the\n"
20012 " matrix a and world coordinates. If\n"
20013 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20014 " indices of a are mapped to the range\n"
20015 " xmin through\n"
20016 " xmax and the y indices of a are mapped to the range\n"
20017 " ymin through\n"
20018 " ymax.For the C case, transformation functions are provided in the\n"
20019 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20020 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20021 " matrices. In addition, C callback routines for the transformation\n"
20022 " can be supplied by the user such as the mypltr function in\n"
20023 " examples/c/x09c.c which provides a general linear transformation\n"
20024 " between index coordinates and world coordinates.For languages\n"
20025 " other than C you should consult the PLplot documentation for the\n"
20026 " details concerning how PLTRANSFORM_callback arguments are\n"
20027 " interfaced. However, in general, a particular pattern of\n"
20028 " callback-associated arguments such as a tr vector with 6 elements;\n"
20029 " xg and yg vectors; or xg and yg matrices are respectively\n"
20030 " interfaced to a linear-transformation routine similar to the above\n"
20031 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20032 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20033 " support native language callbacks for handling index to\n"
20034 " world-coordinate transformations. Examples of these various\n"
20035 " approaches are given in examples/<language>x09*,\n"
20036 " examples/<language>x16*, examples/<language>x20*,\n"
20037 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20038 " supported languages.\n"
20039 "\n"
20040 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20041 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20042 " externally supplied.\n"
20043 "\n"
20044 ""},
20045 { "plshade", _wrap_plshade, METH_VARARGS, "\n"
20046 "Shade individual region on the basis of value\n"
20047 "\n"
20048 "DESCRIPTION:\n"
20049 "\n"
20050 " Shade individual region on the basis of value. Use plshades if you\n"
20051 " want to shade a number of contiguous regions using continuous colors.\n"
20052 " In particular the edge contours are treated properly in plshades. If\n"
20053 " you attempt to do contiguous regions with plshade the contours at the\n"
20054 " edge of the shade are partially obliterated by subsequent plots of\n"
20055 " contiguous shaded regions.\n"
20056 "\n"
20057 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20058 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20059 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20060 "\n"
20061 "\n"
20062 " This function is used in example 15.\n"
20063 "\n"
20064 "\n"
20065 "\n"
20066 "SYNOPSIS:\n"
20067 "\n"
20068 "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"
20069 "\n"
20070 "ARGUMENTS:\n"
20071 "\n"
20072 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20073 " plot. Should have dimensions of\n"
20074 " nx by\n"
20075 " ny.\n"
20076 "\n"
20077 " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20078 "\n"
20079 " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20080 "\n"
20081 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20082 " the region that should be plotted in the shade plot. This\n"
20083 " function accepts x and y coordinates as input arguments and must\n"
20084 " return 1 if the point is to be included in the shade plot and 0\n"
20085 " otherwise. If you want to plot the entire shade plot (the usual\n"
20086 " case), this argument should be set to NULL.\n"
20087 "\n"
20088 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20089 " pltr below for how these arguments are used (only for the special case\n"
20090 " when the callback function\n"
20091 " pltr is not supplied).\n"
20092 "\n"
20093 " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20094 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20095 "\n"
20096 " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20097 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20098 "\n"
20099 " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20100 " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20101 " then sh_color is interpreted as a cmap1 argument in the range\n"
20102 " (0.0-1.0).\n"
20103 "\n"
20104 " sh_color (PLFLT, input) : Defines color map index with integer\n"
20105 " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20106 "\n"
20107 " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20108 "\n"
20109 " min_color (PLINT, input) : Defines pen color, width used by the\n"
20110 " boundary of shaded region. The min values are used for the\n"
20111 " shade_min boundary, and the max values are used on the shade_max\n"
20112 " boundary. Set color and width to zero for no plotted boundaries.\n"
20113 "\n"
20114 " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20115 " boundary of shaded region. The min values are used for the\n"
20116 " shade_min boundary, and the max values are used on the shade_max\n"
20117 " boundary. Set color and width to zero for no plotted boundaries.\n"
20118 "\n"
20119 " max_color (PLINT, input) : Defines pen color, width used by the\n"
20120 " boundary of shaded region. The min values are used for the\n"
20121 " shade_min boundary, and the max values are used on the shade_max\n"
20122 " boundary. Set color and width to zero for no plotted boundaries.\n"
20123 "\n"
20124 " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20125 " boundary of shaded region. The min values are used for the\n"
20126 " shade_min boundary, and the max values are used on the shade_max\n"
20127 " boundary. Set color and width to zero for no plotted boundaries.\n"
20128 "\n"
20129 " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20130 " Use plfill. Future version of PLplot may have other fill\n"
20131 " routines.\n"
20132 "\n"
20133 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20134 " map to rectangles after coordinate transformation with pltrl.\n"
20135 " Otherwise, set rectangular to false. If rectangular is set to\n"
20136 " true, plshade tries to save time by filling large rectangles.\n"
20137 " This optimization fails if the coordinate transformation distorts\n"
20138 " the shape of rectangles. For example a plot in polar coordinates\n"
20139 " has to have rectangular set to false.\n"
20140 "\n"
20141 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20142 " defines the transformation between the zero-based indices of the\n"
20143 " matrix a and world coordinates. If\n"
20144 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20145 " indices of a are mapped to the range\n"
20146 " xmin through\n"
20147 " xmax and the y indices of a are mapped to the range\n"
20148 " ymin through\n"
20149 " ymax.For the C case, transformation functions are provided in the\n"
20150 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20151 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20152 " matrices. In addition, C callback routines for the transformation\n"
20153 " can be supplied by the user such as the mypltr function in\n"
20154 " examples/c/x09c.c which provides a general linear transformation\n"
20155 " between index coordinates and world coordinates.For languages\n"
20156 " other than C you should consult the PLplot documentation for the\n"
20157 " details concerning how PLTRANSFORM_callback arguments are\n"
20158 " interfaced. However, in general, a particular pattern of\n"
20159 " callback-associated arguments such as a tr vector with 6 elements;\n"
20160 " xg and yg vectors; or xg and yg matrices are respectively\n"
20161 " interfaced to a linear-transformation routine similar to the above\n"
20162 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20163 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20164 " support native language callbacks for handling index to\n"
20165 " world-coordinate transformations. Examples of these various\n"
20166 " approaches are given in examples/<language>x09*,\n"
20167 " examples/<language>x16*, examples/<language>x20*,\n"
20168 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20169 " supported languages.\n"
20170 "\n"
20171 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20172 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20173 " externally supplied.\n"
20174 "\n"
20175 ""},
20176 { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, "\n"
20177 "Assign a function to use for generating custom axis labels\n"
20178 "\n"
20179 "DESCRIPTION:\n"
20180 "\n"
20181 " This function allows a user to provide their own function to provide\n"
20182 " axis label text. The user function is given the numeric value for a\n"
20183 " point on an axis and returns a string label to correspond with that\n"
20184 " value. Custom axis labels can be enabled by passing appropriate\n"
20185 " arguments to plenv, plbox, plbox3 and similar functions.\n"
20186 "\n"
20187 " This function is used in example 19.\n"
20188 "\n"
20189 "\n"
20190 "\n"
20191 "SYNOPSIS:\n"
20192 "\n"
20193 "plslabelfunc(label_func, label_data)\n"
20194 "\n"
20195 "ARGUMENTS:\n"
20196 "\n"
20197 " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20198 " label function. In order to reset to the default labelling, set\n"
20199 " this to NULL. The labelling function parameters are, in order:\n"
20200 " axis: This indicates which axis a label is being requested for.\n"
20201 " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20202 "\n"
20203 " value: This is the value along the axis which is being labelled.\n"
20204 "\n"
20205 " label_text: The string representation of the label value.\n"
20206 "\n"
20207 " length: The maximum length in characters allowed for label_text.\n"
20208 "\n"
20209 "\n"
20210 " label_data (PLPointer, input) : This parameter may be used to pass\n"
20211 " data to the label_func function.\n"
20212 "\n"
20213 ""},
20214 { "plsmaj", _wrap_plsmaj, METH_VARARGS, "\n"
20215 "Set length of major ticks\n"
20216 "\n"
20217 "DESCRIPTION:\n"
20218 "\n"
20219 " This sets up the length of the major ticks. The actual length is the\n"
20220 " product of the default length and a scaling factor as for character\n"
20221 " height.\n"
20222 "\n"
20223 " Redacted form: plsmaj(def, scale)\n"
20224 "\n"
20225 " This function is used in example 29.\n"
20226 "\n"
20227 "\n"
20228 "\n"
20229 "SYNOPSIS:\n"
20230 "\n"
20231 "plsmaj(def, scale)\n"
20232 "\n"
20233 "ARGUMENTS:\n"
20234 "\n"
20235 " def (PLFLT, input) : The default length of a major tick in\n"
20236 " millimeters, should be set to zero if the default length is to\n"
20237 " remain unchanged.\n"
20238 "\n"
20239 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20240 " actual tick length.\n"
20241 "\n"
20242 ""},
20243 { "plsmem", _wrap_plsmem, METH_VARARGS, "\n"
20244 "Set the memory area to be plotted (RGB)\n"
20245 "\n"
20246 "DESCRIPTION:\n"
20247 "\n"
20248 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20249 " the dev member of the stream structure. Also set the number of pixels\n"
20250 " in the memory passed in\n"
20251 " plotmem, which is a block of memory\n"
20252 " maxy by\n"
20253 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
20254 "\n"
20255 " This memory will have to be freed by the user!\n"
20256 "\n"
20257 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20258 "\n"
20259 " This function is not used in any examples.\n"
20260 "\n"
20261 "\n"
20262 "\n"
20263 "SYNOPSIS:\n"
20264 "\n"
20265 "plsmem(maxx, maxy, plotmem)\n"
20266 "\n"
20267 "ARGUMENTS:\n"
20268 "\n"
20269 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20270 "\n"
20271 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20272 "\n"
20273 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
20274 " user-supplied writeable memory area.\n"
20275 "\n"
20276 ""},
20277 { "plsmema", _wrap_plsmema, METH_VARARGS, "\n"
20278 "Set the memory area to be plotted (RGBA)\n"
20279 "\n"
20280 "DESCRIPTION:\n"
20281 "\n"
20282 " Set the memory area to be plotted (with the memcairo driver) as the\n"
20283 " dev member of the stream structure. Also set the number of pixels in\n"
20284 " the memory passed in\n"
20285 " plotmem, which is a block of memory\n"
20286 " maxy by\n"
20287 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
20288 "\n"
20289 " This memory will have to be freed by the user!\n"
20290 "\n"
20291 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
20292 "\n"
20293 " This function is not used in any examples.\n"
20294 "\n"
20295 "\n"
20296 "\n"
20297 "SYNOPSIS:\n"
20298 "\n"
20299 "plsmema(maxx, maxy, plotmem)\n"
20300 "\n"
20301 "ARGUMENTS:\n"
20302 "\n"
20303 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20304 "\n"
20305 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20306 "\n"
20307 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
20308 " user-supplied writeable memory area.\n"
20309 "\n"
20310 ""},
20311 { "plsmin", _wrap_plsmin, METH_VARARGS, "\n"
20312 "Set length of minor ticks\n"
20313 "\n"
20314 "DESCRIPTION:\n"
20315 "\n"
20316 " This sets up the length of the minor ticks and the length of the\n"
20317 " terminals on error bars. The actual length is the product of the\n"
20318 " default length and a scaling factor as for character height.\n"
20319 "\n"
20320 " Redacted form: plsmin(def, scale)\n"
20321 "\n"
20322 " This function is used in example 29.\n"
20323 "\n"
20324 "\n"
20325 "\n"
20326 "SYNOPSIS:\n"
20327 "\n"
20328 "plsmin(def, scale)\n"
20329 "\n"
20330 "ARGUMENTS:\n"
20331 "\n"
20332 " def (PLFLT, input) : The default length of a minor tick in\n"
20333 " millimeters, should be set to zero if the default length is to\n"
20334 " remain unchanged.\n"
20335 "\n"
20336 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20337 " actual tick length.\n"
20338 "\n"
20339 ""},
20340 { "plsori", _wrap_plsori, METH_O, "\n"
20341 "Set orientation\n"
20342 "\n"
20343 "DESCRIPTION:\n"
20344 "\n"
20345 " Set integer plot orientation parameter. This function is identical to\n"
20346 " plsdiori except for the type of the argument, and should be used in\n"
20347 " the same way. See the documentation of plsdiori for details.\n"
20348 "\n"
20349 " Redacted form: plsori(ori)\n"
20350 "\n"
20351 " This function is used in example 3.\n"
20352 "\n"
20353 "\n"
20354 "\n"
20355 "SYNOPSIS:\n"
20356 "\n"
20357 "plsori(ori)\n"
20358 "\n"
20359 "ARGUMENTS:\n"
20360 "\n"
20361 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
20362 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
20363 " angle.\n"
20364 "\n"
20365 ""},
20366 { "plspage", _wrap_plspage, METH_VARARGS, "\n"
20367 "Set page parameters\n"
20368 "\n"
20369 "DESCRIPTION:\n"
20370 "\n"
20371 " Sets the page configuration (optional). If an individual parameter is\n"
20372 " zero then that parameter value is not updated. Not all parameters are\n"
20373 " recognized by all drivers and the interpretation is device-dependent.\n"
20374 " The X-window driver uses the length and offset parameters to determine\n"
20375 " the window size and location. The length and offset values are\n"
20376 " expressed in units that are specific to the current driver. For\n"
20377 " instance: screen drivers will usually interpret them as number of\n"
20378 " pixels, whereas printer drivers will usually use mm.\n"
20379 "\n"
20380 " This routine, if used, must be called before initializing PLplot. It\n"
20381 " may be called at later times for interactive drivers to change only\n"
20382 " the dpi for subsequent redraws which you can force via a call to\n"
20383 " plreplot. If this function is not called then the page size defaults\n"
20384 " to landscape A4 for drivers which use real world page sizes and 744\n"
20385 " pixels wide by 538 pixels high for raster drivers. The default value\n"
20386 " for dx and dy is 90 pixels per inch for raster drivers.\n"
20387 "\n"
20388 "\n"
20389 "\n"
20390 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20391 "\n"
20392 " This function is used in examples 14 and 31.\n"
20393 "\n"
20394 "\n"
20395 "\n"
20396 "SYNOPSIS:\n"
20397 "\n"
20398 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20399 "\n"
20400 "ARGUMENTS:\n"
20401 "\n"
20402 " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
20403 " by raster drivers, ignored by drivers which use \"real world\" units\n"
20404 " (e.g. mm).\n"
20405 "\n"
20406 " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
20407 " by raster drivers, ignored by drivers which use \"real world\" units\n"
20408 " (e.g. mm).\n"
20409 "\n"
20410 " xleng (PLINT, input) : Page length, x.\n"
20411 "\n"
20412 " yleng (PLINT, input) : Page length, y.\n"
20413 "\n"
20414 " xoff (PLINT, input) : Page offset, x.\n"
20415 "\n"
20416 " yoff (PLINT, input) : Page offset, y.\n"
20417 "\n"
20418 ""},
20419 { "plspal0", _wrap_plspal0, METH_O, "\n"
20420 "Set the cmap0 palette using the specified cmap0*.pal format file\n"
20421 "\n"
20422 "DESCRIPTION:\n"
20423 "\n"
20424 " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
20425 "\n"
20426 " Redacted form: plspal0(filename)\n"
20427 "\n"
20428 " This function is in example 16.\n"
20429 "\n"
20430 "\n"
20431 "\n"
20432 "SYNOPSIS:\n"
20433 "\n"
20434 "plspal0(filename)\n"
20435 "\n"
20436 "ARGUMENTS:\n"
20437 "\n"
20438 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
20439 " containing the name of the cmap0*.pal file. If this string is\n"
20440 " empty, use the default cmap0*.pal file.\n"
20441 "\n"
20442 ""},
20443 { "plspal1", _wrap_plspal1, METH_VARARGS, "\n"
20444 "Set the cmap1 palette using the specified cmap1*.pal format file\n"
20445 "\n"
20446 "DESCRIPTION:\n"
20447 "\n"
20448 " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
20449 "\n"
20450 " Redacted form: plspal1(filename, interpolate)\n"
20451 "\n"
20452 " This function is used in example 16.\n"
20453 "\n"
20454 "\n"
20455 "\n"
20456 "SYNOPSIS:\n"
20457 "\n"
20458 "plspal1(filename, interpolate)\n"
20459 "\n"
20460 "ARGUMENTS:\n"
20461 "\n"
20462 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
20463 " containing the name of the cmap1*.pal file. If this string is\n"
20464 " empty, use the default cmap1*.pal file.\n"
20465 "\n"
20466 " interpolate (PLBOOL, input) : If this parameter is true, the\n"
20467 " columns containing the intensity index, r, g, b, alpha and\n"
20468 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
20469 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
20470 " a flag which controls whether the r, g, b data sent to plscmap1la\n"
20471 " are interpreted as HLS or RGB.) If this parameter is false, the\n"
20472 " intensity index and alt_hue_path columns are ignored and the r, g,\n"
20473 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
20474 " are used instead to set the cmap1 palette directly with a call to\n"
20475 " plscmap1a.\n"
20476 "\n"
20477 ""},
20478 { "plspause", _wrap_plspause, METH_O, "\n"
20479 "Set the pause (on end-of-page) status\n"
20480 "\n"
20481 "DESCRIPTION:\n"
20482 "\n"
20483 " Set the pause (on end-of-page) status.\n"
20484 "\n"
20485 " Redacted form: plspause(pause)\n"
20486 "\n"
20487 " This function is in examples 14,20.\n"
20488 "\n"
20489 "\n"
20490 "\n"
20491 "SYNOPSIS:\n"
20492 "\n"
20493 "plspause(pause)\n"
20494 "\n"
20495 "ARGUMENTS:\n"
20496 "\n"
20497 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
20498 " end-of-page for those drivers which support this. Otherwise there\n"
20499 " is no pause.\n"
20500 "\n"
20501 ""},
20502 { "plsstrm", _wrap_plsstrm, METH_O, "\n"
20503 "Set current output stream\n"
20504 "\n"
20505 "DESCRIPTION:\n"
20506 "\n"
20507 " Sets the number of the current output stream. The stream number\n"
20508 " defaults to 0 unless changed by this routine. The first use of this\n"
20509 " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
20510 "\n"
20511 " Redacted form: plsstrm(strm)\n"
20512 "\n"
20513 " This function is examples 1,14,20.\n"
20514 "\n"
20515 "\n"
20516 "\n"
20517 "SYNOPSIS:\n"
20518 "\n"
20519 "plsstrm(strm)\n"
20520 "\n"
20521 "ARGUMENTS:\n"
20522 "\n"
20523 " strm (PLINT, input) : The current stream number.\n"
20524 "\n"
20525 ""},
20526 { "plssub", _wrap_plssub, METH_VARARGS, "\n"
20527 "Set the number of subpages in x and y\n"
20528 "\n"
20529 "DESCRIPTION:\n"
20530 "\n"
20531 " Set the number of subpages in x and y.\n"
20532 "\n"
20533 " Redacted form: plssub(nx, ny)\n"
20534 "\n"
20535 " This function is examples 1,2,14,21,25,27.\n"
20536 "\n"
20537 "\n"
20538 "\n"
20539 "SYNOPSIS:\n"
20540 "\n"
20541 "plssub(nx, ny)\n"
20542 "\n"
20543 "ARGUMENTS:\n"
20544 "\n"
20545 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
20546 " of window columns).\n"
20547 "\n"
20548 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
20549 " of window rows).\n"
20550 "\n"
20551 ""},
20552 { "plssym", _wrap_plssym, METH_VARARGS, "\n"
20553 "Set symbol size\n"
20554 "\n"
20555 "DESCRIPTION:\n"
20556 "\n"
20557 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
20558 " plsym. The actual height of a symbol is the product of the default\n"
20559 " symbol size and a scaling factor as for the character height.\n"
20560 "\n"
20561 " Redacted form: plssym(def, scale)\n"
20562 "\n"
20563 " This function is used in example 29.\n"
20564 "\n"
20565 "\n"
20566 "\n"
20567 "SYNOPSIS:\n"
20568 "\n"
20569 "plssym(def, scale)\n"
20570 "\n"
20571 "ARGUMENTS:\n"
20572 "\n"
20573 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
20574 " should be set to zero if the default height is to remain\n"
20575 " unchanged.\n"
20576 "\n"
20577 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20578 " actual symbol height.\n"
20579 "\n"
20580 ""},
20581 { "plstar", _wrap_plstar, METH_VARARGS, "\n"
20582 "Initialization\n"
20583 "\n"
20584 "DESCRIPTION:\n"
20585 "\n"
20586 " Initializing the plotting package. The program prompts for the device\n"
20587 " keyword or number of the desired output device. Hitting a RETURN in\n"
20588 " response to the prompt is the same as selecting the first device. If\n"
20589 " only one device is enabled when PLplot is installed, plstar will issue\n"
20590 " no prompt. The output device is divided into nx by ny subpages, each\n"
20591 " of which may be used independently. The subroutine pladv is used to\n"
20592 " advance from one subpage to the next.\n"
20593 "\n"
20594 " Redacted form: plstar(nx, ny)\n"
20595 "\n"
20596 " This function is used in example 1.\n"
20597 "\n"
20598 "\n"
20599 "\n"
20600 "SYNOPSIS:\n"
20601 "\n"
20602 "plstar(nx, ny)\n"
20603 "\n"
20604 "ARGUMENTS:\n"
20605 "\n"
20606 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20607 " x direction.\n"
20608 "\n"
20609 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20610 " y direction.\n"
20611 "\n"
20612 ""},
20613 { "plstart", _wrap_plstart, METH_VARARGS, "\n"
20614 "Initialization\n"
20615 "\n"
20616 "DESCRIPTION:\n"
20617 "\n"
20618 " Alternative to plstar for initializing the plotting package. The\n"
20619 " device name keyword for the desired output device must be supplied as\n"
20620 " an argument. These keywords are the same as those printed out by\n"
20621 " plstar. If the requested device is not available, or if the input\n"
20622 " string is empty or begins with ``?'', the prompted start up of plstar\n"
20623 " is used. This routine also divides the output device page into nx by\n"
20624 " ny subpages, each of which may be used independently. The subroutine\n"
20625 " pladv is used to advance from one subpage to the next.\n"
20626 "\n"
20627 " Redacted form: General: plstart(devname, nx, ny)\n"
20628 "\n"
20629 "\n"
20630 " This function is not used in any examples.\n"
20631 "\n"
20632 "\n"
20633 "\n"
20634 "SYNOPSIS:\n"
20635 "\n"
20636 "plstart(devname, nx, ny)\n"
20637 "\n"
20638 "ARGUMENTS:\n"
20639 "\n"
20640 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20641 " containing the device name keyword of the required output device.\n"
20642 " If\n"
20643 " devname is NULL or if the first character of the string is a ``?'',\n"
20644 " the normal (prompted) start up is used.\n"
20645 "\n"
20646 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20647 " x direction.\n"
20648 "\n"
20649 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20650 " y direction.\n"
20651 "\n"
20652 ""},
20653 { "plstransform", _wrap_plstransform, METH_VARARGS, "\n"
20654 "Set a global coordinate transform function\n"
20655 "\n"
20656 "DESCRIPTION:\n"
20657 "\n"
20658 " This function can be used to define a coordinate transformation which\n"
20659 " affects all elements drawn within the current plot window. The\n"
20660 " coordinate_transform callback function is similar to that provided for\n"
20661 " the plmap and plmeridians functions. The coordinate_transform_data\n"
20662 " parameter may be used to pass extra data to coordinate_transform.\n"
20663 "\n"
20664 " Redacted form: General: plstransform(coordinate_transform,\n"
20665 " coordinate_transform_data)\n"
20666 "\n"
20667 "\n"
20668 " This function is used in examples 19 and 22.\n"
20669 "\n"
20670 "\n"
20671 "\n"
20672 "SYNOPSIS:\n"
20673 "\n"
20674 "plstransform(coordinate_transform, coordinate_transform_data)\n"
20675 "\n"
20676 "ARGUMENTS:\n"
20677 "\n"
20678 " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
20679 " function that defines the transformation from the input (x, y)\n"
20680 " world coordinates to new PLplot world coordinates. If\n"
20681 " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
20682 " case), then no transform is applied.\n"
20683 "\n"
20684 " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
20685 " for\n"
20686 " coordinate_transform.\n"
20687 "\n"
20688 ""},
20689 { "plstring", _wrap_plstring, METH_VARARGS, "\n"
20690 "Plot a glyph at the specified points\n"
20691 "\n"
20692 "DESCRIPTION:\n"
20693 "\n"
20694 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
20695 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
20696 " is specified with a PLplot user string. Note that the user string is\n"
20697 " not actually limited to one glyph so it is possible (but not normally\n"
20698 " useful) to plot more than one glyph at the specified points with this\n"
20699 " function. As with plmtex and plptex, the user string can contain FCI\n"
20700 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
20701 " else PLplot escapes for Hershey or unicode text to determine the\n"
20702 " glyph.\n"
20703 "\n"
20704 " Redacted form: plstring(x, y, string)\n"
20705 "\n"
20706 " This function is used in examples 4, 21 and 26.\n"
20707 "\n"
20708 "\n"
20709 "\n"
20710 "SYNOPSIS:\n"
20711 "\n"
20712 "plstring(n, x, y, string)\n"
20713 "\n"
20714 "ARGUMENTS:\n"
20715 "\n"
20716 " n (PLINT, input) : Number of points in the x and y vectors.\n"
20717 "\n"
20718 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
20719 " the points.\n"
20720 "\n"
20721 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
20722 " the points.\n"
20723 "\n"
20724 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20725 " the glyph(s) to be plotted at each of the n points.\n"
20726 "\n"
20727 ""},
20728 { "plstring3", _wrap_plstring3, METH_VARARGS, "\n"
20729 "Plot a glyph at the specified 3D points\n"
20730 "\n"
20731 "DESCRIPTION:\n"
20732 "\n"
20733 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
20734 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
20735 " this function similar to what is done for plline3. The glyph is\n"
20736 " specified with a PLplot user string. Note that the user string is not\n"
20737 " actually limited to one glyph so it is possible (but not normally\n"
20738 " useful) to plot more than one glyph at the specified points with this\n"
20739 " function. As with plmtex and plptex, the user string can contain FCI\n"
20740 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
20741 " else PLplot escapes for Hershey or unicode text to determine the\n"
20742 " glyph.\n"
20743 "\n"
20744 " Redacted form: plstring3(x, y, z, string)\n"
20745 "\n"
20746 " This function is used in example 18.\n"
20747 "\n"
20748 "\n"
20749 "\n"
20750 "SYNOPSIS:\n"
20751 "\n"
20752 "plstring3(n, x, y, z, string)\n"
20753 "\n"
20754 "ARGUMENTS:\n"
20755 "\n"
20756 " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
20757 "\n"
20758 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
20759 " the points.\n"
20760 "\n"
20761 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
20762 " the points.\n"
20763 "\n"
20764 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
20765 " the points.\n"
20766 "\n"
20767 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20768 " the glyph(s) to be plotted at each of the n points. points.\n"
20769 "\n"
20770 ""},
20771 { "plstripa", _wrap_plstripa, METH_VARARGS, "\n"
20772 "Add a point to a strip chart\n"
20773 "\n"
20774 "DESCRIPTION:\n"
20775 "\n"
20776 " Add a point to a given pen of a given strip chart. There is no need\n"
20777 " for all pens to have the same number of points or to be equally\n"
20778 " sampled in the x coordinate. Allocates memory and rescales as\n"
20779 " necessary.\n"
20780 "\n"
20781 " Redacted form: plstripa(id, pen, x, y)\n"
20782 "\n"
20783 " This function is used in example 17.\n"
20784 "\n"
20785 "\n"
20786 "\n"
20787 "SYNOPSIS:\n"
20788 "\n"
20789 "plstripa(id, pen, x, y)\n"
20790 "\n"
20791 "ARGUMENTS:\n"
20792 "\n"
20793 " id (PLINT, input) : Identification number of the strip chart (set\n"
20794 " up in plstripc).\n"
20795 "\n"
20796 " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
20797 "\n"
20798 " x (PLFLT, input) : X coordinate of point to plot.\n"
20799 "\n"
20800 " y (PLFLT, input) : Y coordinate of point to plot.\n"
20801 "\n"
20802 ""},
20803 { "plstripc", _wrap_plstripc, METH_VARARGS, "\n"
20804 "Create a 4-pen strip chart\n"
20805 "\n"
20806 "DESCRIPTION:\n"
20807 "\n"
20808 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
20809 "\n"
20810 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
20811 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
20812 " styline, legline, labx, laby, labz)\n"
20813 "\n"
20814 "\n"
20815 " This function is used in example 17.\n"
20816 "\n"
20817 "\n"
20818 "\n"
20819 "SYNOPSIS:\n"
20820 "\n"
20821 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
20822 "\n"
20823 "ARGUMENTS:\n"
20824 "\n"
20825 " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
20826 " number of the strip chart to use on plstripa and plstripd.\n"
20827 "\n"
20828 " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20829 " the x-axis specification as in plbox.\n"
20830 "\n"
20831 " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20832 " the y-axis specification as in plbox.\n"
20833 "\n"
20834 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
20835 " change as data are added.\n"
20836 "\n"
20837 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
20838 " change as data are added.\n"
20839 "\n"
20840 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
20841 " is multiplied by the factor (1 +\n"
20842 " xjump) .\n"
20843 "\n"
20844 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
20845 " change as data are added.\n"
20846 "\n"
20847 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
20848 " change as data are added.\n"
20849 "\n"
20850 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
20851 "\n"
20852 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
20853 "\n"
20854 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
20855 " true, otherwise not.\n"
20856 "\n"
20857 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
20858 " otherwise slide display.\n"
20859 "\n"
20860 " colbox (PLINT, input) : Plot box color index (cmap0).\n"
20861 "\n"
20862 " collab (PLINT, input) : Legend color index (cmap0).\n"
20863 "\n"
20864 " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
20865 " indices for the 4 pens.\n"
20866 "\n"
20867 " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
20868 " indices for the 4 pens.\n"
20869 "\n"
20870 " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
20871 " strings containing legends for the 4 pens.\n"
20872 "\n"
20873 " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20874 " the label for the x axis.\n"
20875 "\n"
20876 " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20877 " the label for the y axis.\n"
20878 "\n"
20879 " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
20880 " the plot title.\n"
20881 "\n"
20882 ""},
20883 { "plstripd", _wrap_plstripd, METH_O, "\n"
20884 "Deletes and releases memory used by a strip chart\n"
20885 "\n"
20886 "DESCRIPTION:\n"
20887 "\n"
20888 " Deletes and releases memory used by a strip chart.\n"
20889 "\n"
20890 " Redacted form: plstripd(id)\n"
20891 "\n"
20892 " This function is used in example 17.\n"
20893 "\n"
20894 "\n"
20895 "\n"
20896 "SYNOPSIS:\n"
20897 "\n"
20898 "plstripd(id)\n"
20899 "\n"
20900 "ARGUMENTS:\n"
20901 "\n"
20902 " id (PLINT, input) : Identification number of strip chart to delete.\n"
20903 "\n"
20904 ""},
20905 { "plstyl", _wrap_plstyl, METH_VARARGS, "\n"
20906 "Set line style\n"
20907 "\n"
20908 "DESCRIPTION:\n"
20909 "\n"
20910 " This sets up the line style for all lines subsequently drawn. A line\n"
20911 " consists of segments in which the pen is alternately down and up. The\n"
20912 " lengths of these segments are passed in the vectors mark and space\n"
20913 " respectively. The number of mark-space pairs is specified by nms. In\n"
20914 " order to return the line style to the default continuous line, plstyl\n"
20915 " should be called with nms =0 .(see also pllsty)\n"
20916 "\n"
20917 " Redacted form: plstyl(mark, space)\n"
20918 "\n"
20919 " This function is used in examples 1, 9, and 14.\n"
20920 "\n"
20921 "\n"
20922 "\n"
20923 "SYNOPSIS:\n"
20924 "\n"
20925 "plstyl(nms, mark, space)\n"
20926 "\n"
20927 "ARGUMENTS:\n"
20928 "\n"
20929 " nms (PLINT, input) : The number of mark and space elements in a\n"
20930 " line. Thus a simple broken line can be obtained by setting nms=1\n"
20931 " . A continuous line is specified by setting nms=0 .\n"
20932 "\n"
20933 " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
20934 " segments during which the pen is down, measured in micrometers.\n"
20935 "\n"
20936 " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
20937 " the segments during which the pen is up, measured in micrometers.\n"
20938 "\n"
20939 ""},
20940 { "plsvect", _wrap_plsvect, METH_VARARGS, "\n"
20941 "Set arrow style for vector plots\n"
20942 "\n"
20943 "DESCRIPTION:\n"
20944 "\n"
20945 " Set the style for the arrow used by plvect to plot vectors.\n"
20946 "\n"
20947 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
20948 "\n"
20949 " This function is used in example 22.\n"
20950 "\n"
20951 "\n"
20952 "\n"
20953 "SYNOPSIS:\n"
20954 "\n"
20955 "plsvect(arrowx, arrowy, npts, fill)\n"
20956 "\n"
20957 "ARGUMENTS:\n"
20958 "\n"
20959 " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
20960 " the x and y points which make up the arrow. The arrow is plotted\n"
20961 " by joining these points to form a polygon. The scaling assumes\n"
20962 " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
20963 " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
20964 " will be reset to its default.\n"
20965 "\n"
20966 " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
20967 " arrowy.\n"
20968 "\n"
20969 " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
20970 " fill is false then the arrow is open.\n"
20971 "\n"
20972 ""},
20973 { "plsvpa", _wrap_plsvpa, METH_VARARGS, "\n"
20974 "Specify viewport in absolute coordinates\n"
20975 "\n"
20976 "DESCRIPTION:\n"
20977 "\n"
20978 " Alternate routine to plvpor for setting up the viewport. This routine\n"
20979 " should be used only if the viewport is required to have a definite\n"
20980 " size in millimeters. The routine plgspa is useful for finding out the\n"
20981 " size of the current subpage.\n"
20982 "\n"
20983 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
20984 "\n"
20985 " This function is used in example 10.\n"
20986 "\n"
20987 "\n"
20988 "\n"
20989 "SYNOPSIS:\n"
20990 "\n"
20991 "plsvpa(xmin, xmax, ymin, ymax)\n"
20992 "\n"
20993 "ARGUMENTS:\n"
20994 "\n"
20995 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
20996 " viewport from the left-hand edge of the subpage in millimeters.\n"
20997 "\n"
20998 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
20999 " viewport from the left-hand edge of the subpage in millimeters.\n"
21000 "\n"
21001 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21002 " viewport from the bottom edge of the subpage in millimeters.\n"
21003 "\n"
21004 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21005 " from the bottom edge of the subpage in millimeters.\n"
21006 "\n"
21007 ""},
21008 { "plsxax", _wrap_plsxax, METH_VARARGS, "\n"
21009 "Set x axis parameters\n"
21010 "\n"
21011 "DESCRIPTION:\n"
21012 "\n"
21013 " Sets values of the digmax and digits flags for the x axis. See the\n"
21014 " PLplot documentation for more information.\n"
21015 "\n"
21016 " Redacted form: plsxax(digmax, digits)\n"
21017 "\n"
21018 " This function is used in example 31.\n"
21019 "\n"
21020 "\n"
21021 "\n"
21022 "SYNOPSIS:\n"
21023 "\n"
21024 "plsxax(digmax, digits)\n"
21025 "\n"
21026 "ARGUMENTS:\n"
21027 "\n"
21028 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21029 " digits for the x axis. If nonzero, the printed label will be\n"
21030 " switched to a floating-point representation when the number of\n"
21031 " digits exceeds digmax.\n"
21032 "\n"
21033 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21034 " its value here has no effect since it is set only by plbox or\n"
21035 " plbox3. However, the user may obtain its value after a call to\n"
21036 " either of these functions by calling plgxax.\n"
21037 "\n"
21038 ""},
21039 { "plsyax", _wrap_plsyax, METH_VARARGS, "\n"
21040 "Set y axis parameters\n"
21041 "\n"
21042 "DESCRIPTION:\n"
21043 "\n"
21044 " Identical to plsxax, except that arguments are flags for y axis. See\n"
21045 " the description of plsxax for more detail.\n"
21046 "\n"
21047 " Redacted form: plsyax(digmax, digits)\n"
21048 "\n"
21049 " This function is used in examples 1, 14, and 31.\n"
21050 "\n"
21051 "\n"
21052 "\n"
21053 "SYNOPSIS:\n"
21054 "\n"
21055 "plsyax(digmax, digits)\n"
21056 "\n"
21057 "ARGUMENTS:\n"
21058 "\n"
21059 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21060 " digits for the y axis. If nonzero, the printed label will be\n"
21061 " switched to a floating-point representation when the number of\n"
21062 " digits exceeds digmax.\n"
21063 "\n"
21064 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21065 " its value here has no effect since it is set only by plbox or\n"
21066 " plbox3. However, the user may obtain its value after a call to\n"
21067 " either of these functions by calling plgyax.\n"
21068 "\n"
21069 ""},
21070 { "plsym", _wrap_plsym, METH_VARARGS, "\n"
21071 "Plot a glyph at the specified points\n"
21072 "\n"
21073 "DESCRIPTION:\n"
21074 "\n"
21075 " Plot a glyph at the specified points. (This function is largely\n"
21076 " superseded by plstring which gives access to many[!] more glyphs.)\n"
21077 "\n"
21078 " Redacted form: plsym(x, y, code)\n"
21079 "\n"
21080 " This function is used in example 7.\n"
21081 "\n"
21082 "\n"
21083 "\n"
21084 "SYNOPSIS:\n"
21085 "\n"
21086 "plsym(n, x, y, code)\n"
21087 "\n"
21088 "ARGUMENTS:\n"
21089 "\n"
21090 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21091 "\n"
21092 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21093 " the points.\n"
21094 "\n"
21095 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21096 " the points.\n"
21097 "\n"
21098 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21099 " to be plotted at each of the n points.\n"
21100 "\n"
21101 ""},
21102 { "plszax", _wrap_plszax, METH_VARARGS, "\n"
21103 "Set z axis parameters\n"
21104 "\n"
21105 "DESCRIPTION:\n"
21106 "\n"
21107 " Identical to plsxax, except that arguments are flags for z axis. See\n"
21108 " the description of plsxax for more detail.\n"
21109 "\n"
21110 " Redacted form: plszax(digmax, digits)\n"
21111 "\n"
21112 " This function is used in example 31.\n"
21113 "\n"
21114 "\n"
21115 "\n"
21116 "SYNOPSIS:\n"
21117 "\n"
21118 "plszax(digmax, digits)\n"
21119 "\n"
21120 "ARGUMENTS:\n"
21121 "\n"
21122 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21123 " digits for the z axis. If nonzero, the printed label will be\n"
21124 " switched to a floating-point representation when the number of\n"
21125 " digits exceeds digmax.\n"
21126 "\n"
21127 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21128 " its value here has no effect since it is set only by plbox or\n"
21129 " plbox3. However, the user may obtain its value after a call to\n"
21130 " either of these functions by calling plgzax.\n"
21131 "\n"
21132 ""},
21133 { "pltext", _wrap_pltext, METH_NOARGS, "\n"
21134 "Switch to text screen\n"
21135 "\n"
21136 "DESCRIPTION:\n"
21137 "\n"
21138 " Sets an interactive device to text mode, used in conjunction with\n"
21139 " plgra to allow graphics and text to be interspersed. On a device\n"
21140 " which supports separate text and graphics windows, this command causes\n"
21141 " control to be switched to the text window. This can be useful for\n"
21142 " printing diagnostic messages or getting user input, which would\n"
21143 " otherwise interfere with the plots. The program must switch back to\n"
21144 " the graphics window before issuing plot commands, as the text (or\n"
21145 " console) device will probably become quite confused otherwise. If\n"
21146 " already in text mode, this command is ignored. It is also ignored on\n"
21147 " devices which only support a single window or use a different method\n"
21148 " for shifting focus (see also plgra).\n"
21149 "\n"
21150 " Redacted form: pltext()\n"
21151 "\n"
21152 " This function is used in example 1.\n"
21153 "\n"
21154 "\n"
21155 "\n"
21156 "SYNOPSIS:\n"
21157 "\n"
21158 "pltext()\n"
21159 "\n"
21160 ""},
21161 { "pltimefmt", _wrap_pltimefmt, METH_O, "\n"
21162 "Set format for date / time labels\n"
21163 "\n"
21164 "DESCRIPTION:\n"
21165 "\n"
21166 " Sets the format for date / time labels. To enable date / time format\n"
21167 " labels see the options to plbox, plbox3, and plenv.\n"
21168 "\n"
21169 " Redacted form: pltimefmt(fmt)\n"
21170 "\n"
21171 " This function is used in example 29.\n"
21172 "\n"
21173 "\n"
21174 "\n"
21175 "SYNOPSIS:\n"
21176 "\n"
21177 "pltimefmt(fmt)\n"
21178 "\n"
21179 "ARGUMENTS:\n"
21180 "\n"
21181 " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21182 " interpreted similarly to the format specifier of typical system\n"
21183 " strftime routines except that PLplot ignores locale and also\n"
21184 " supplies some useful extensions in the context of plotting. All\n"
21185 " text in the string is printed as-is other than conversion\n"
21186 " specifications which take the form of a '%' character followed by\n"
21187 " further conversion specification character. The conversion\n"
21188 " specifications which are similar to those provided by system\n"
21189 " strftime routines are the following: %a: The abbreviated (English)\n"
21190 " weekday name.\n"
21191 " %A: The full (English) weekday name.\n"
21192 " %b: The abbreviated (English) month name.\n"
21193 " %B: The full (English) month name.\n"
21194 " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21195 " %C: The century number (year/100) as a 2-digit integer.\n"
21196 " %d: The day of the month as a decimal number (range 01 to 31).\n"
21197 " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21198 " %e: Like %d, but a leading zero is replaced by a space.\n"
21199 " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21200 " %h: Equivalent to %b.\n"
21201 " %H: The hour as a decimal number using a 24-hour clock (range\n"
21202 " 00 to 23).\n"
21203 " %I: The hour as a decimal number using a 12-hour clock (range\n"
21204 " 01 to 12).\n"
21205 " %j: The day of the year as a decimal number (range 001 to\n"
21206 " 366).\n"
21207 " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21208 " 23); single digits are preceded by a blank. (See also %H.)\n"
21209 " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21210 " 12); single digits are preceded by a blank. (See also %I.)\n"
21211 " %m: The month as a decimal number (range 01 to 12).\n"
21212 " %M: The minute as a decimal number (range 00 to 59).\n"
21213 " %n: A newline character.\n"
21214 " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21215 " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21216 " %r: Equivalent to %I:%M:%S %p.\n"
21217 " %R: The time in 24-hour notation (%H:%M). For a version\n"
21218 " including the seconds, see %T below.\n"
21219 " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21220 " +0000 (UTC).\n"
21221 " %S: The second as a decimal number (range 00 to 60). (The\n"
21222 " range is up to 60 to allow for occasional leap seconds.)\n"
21223 " %t: A tab character.\n"
21224 " %T: The time in 24-hour notation (%H:%M:%S).\n"
21225 " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21226 " being 1. See also %w.\n"
21227 " %U: The week number of the current year as a decimal number,\n"
21228 " range 00 to 53, starting with the first Sunday as the first\n"
21229 " day of week 01. See also %V and %W.\n"
21230 " %v: Equivalent to %e-%b-%Y.\n"
21231 " %V: The ISO 8601 week number of the current year as a decimal\n"
21232 " number, range 01 to 53, where week 1 is the first week that\n"
21233 " has at least 4 days in the new year. See also %U and %W.\n"
21234 " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21235 " being 0. See also %u.\n"
21236 " %W: The week number of the current year as a decimal number,\n"
21237 " range 00 to 53, starting with the first Monday as the first\n"
21238 " day of week 01.\n"
21239 " %x: Equivalent to %a %b %d %Y.\n"
21240 " %X: Equivalent to %T.\n"
21241 " %y: The year as a decimal number without a century (range 00\n"
21242 " to 99).\n"
21243 " %Y: The year as a decimal number including a century.\n"
21244 " %z: The UTC time-zone string = \"+0000\".\n"
21245 " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21246 " %+: The UTC date and time in default format of the Unix date\n"
21247 " command which is equivalent to %a %b %d %T %Z %Y.\n"
21248 " %%: A literal \"%\" character.\n"
21249 " The conversion specifications which are extensions to those normally\n"
21250 " provided by system strftime routines are the following: %(0-9):\n"
21251 " The fractional part of the seconds field (including leading\n"
21252 " decimal point) to the specified accuracy. Thus %S%3 would give\n"
21253 " seconds to millisecond accuracy (00.000).\n"
21254 " %.: The fractional part of the seconds field (including\n"
21255 " leading decimal point) to the maximum available accuracy. Thus\n"
21256 " %S%. would give seconds with fractional part up to 9 decimal\n"
21257 " places if available.\n"
21258 "\n"
21259 ""},
21260 { "plvasp", _wrap_plvasp, METH_O, "\n"
21261 "Specify viewport using aspect ratio only\n"
21262 "\n"
21263 "DESCRIPTION:\n"
21264 "\n"
21265 " Selects the largest viewport with the given aspect ratio within the\n"
21266 " subpage that leaves a standard margin (left-hand margin of eight\n"
21267 " character heights, and a margin around the other three sides of five\n"
21268 " character heights).\n"
21269 "\n"
21270 " Redacted form: plvasp(aspect)\n"
21271 "\n"
21272 " This function is used in example 13.\n"
21273 "\n"
21274 "\n"
21275 "\n"
21276 "SYNOPSIS:\n"
21277 "\n"
21278 "plvasp(aspect)\n"
21279 "\n"
21280 "ARGUMENTS:\n"
21281 "\n"
21282 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21283 " axis of resulting viewport.\n"
21284 "\n"
21285 ""},
21286 { "plvect", _wrap_plvect, METH_VARARGS, "\n"
21287 "Vector plot\n"
21288 "\n"
21289 "DESCRIPTION:\n"
21290 "\n"
21291 " Draws a plot of vector data contained in the matrices (\n"
21292 " u[\n"
21293 " nx][\n"
21294 " ny],\n"
21295 " v[\n"
21296 " nx][\n"
21297 " ny]) . The scaling factor for the vectors is given by scale. A\n"
21298 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
21299 " additional data required by the transformation routine to map indices\n"
21300 " within the matrices to the world coordinates. The style of the vector\n"
21301 " arrow may be set using plsvect.\n"
21302 "\n"
21303 " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
21304 " discussion) the pltr, pltr_data callback arguments are sometimes\n"
21305 " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
21306 " with either one or two dimensions.\n"
21307 "\n"
21308 " This function is used in example 22.\n"
21309 "\n"
21310 "\n"
21311 "\n"
21312 "SYNOPSIS:\n"
21313 "\n"
21314 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
21315 "\n"
21316 "ARGUMENTS:\n"
21317 "\n"
21318 " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
21319 " and y components of the vector data to be plotted.\n"
21320 "\n"
21321 " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
21322 "\n"
21323 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
21324 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
21325 " automatically calculated for the data. If scale < 0 then the\n"
21326 " scaling factor is automatically calculated for the data and then\n"
21327 " multiplied by -\n"
21328 " scale. If scale > 0 then the scaling factor is set to scale.\n"
21329 "\n"
21330 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
21331 " defines the transformation between the zero-based indices of the\n"
21332 " matrices u and v and world coordinates.For the C case,\n"
21333 " transformation functions are provided in the PLplot library: pltr0\n"
21334 " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
21335 " mappings respectively defined by vectors and matrices. In\n"
21336 " addition, C callback routines for the transformation can be\n"
21337 " supplied by the user such as the mypltr function in\n"
21338 " examples/c/x09c.c which provides a general linear transformation\n"
21339 " between index coordinates and world coordinates.For languages\n"
21340 " other than C you should consult the PLplot documentation for the\n"
21341 " details concerning how PLTRANSFORM_callback arguments are\n"
21342 " interfaced. However, in general, a particular pattern of\n"
21343 " callback-associated arguments such as a tr vector with 6 elements;\n"
21344 " xg and yg vectors; or xg and yg matrices are respectively\n"
21345 " interfaced to a linear-transformation routine similar to the above\n"
21346 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
21347 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
21348 " support native language callbacks for handling index to\n"
21349 " world-coordinate transformations. Examples of these various\n"
21350 " approaches are given in examples/<language>x09*,\n"
21351 " examples/<language>x16*, examples/<language>x20*,\n"
21352 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
21353 " supported languages.\n"
21354 "\n"
21355 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
21356 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
21357 " that is externally supplied.\n"
21358 "\n"
21359 ""},
21360 { "plvpas", _wrap_plvpas, METH_VARARGS, "\n"
21361 "Specify viewport using coordinates and aspect ratio\n"
21362 "\n"
21363 "DESCRIPTION:\n"
21364 "\n"
21365 " Device-independent routine for setting up the viewport. The viewport\n"
21366 " is chosen to be the largest with the given aspect ratio that fits\n"
21367 " within the specified region (in terms of normalized subpage\n"
21368 " coordinates). This routine is functionally equivalent to plvpor when\n"
21369 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
21370 " routine reserves no extra space at the edges for labels.\n"
21371 "\n"
21372 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21373 "\n"
21374 " This function is used in example 9.\n"
21375 "\n"
21376 "\n"
21377 "\n"
21378 "SYNOPSIS:\n"
21379 "\n"
21380 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21381 "\n"
21382 "ARGUMENTS:\n"
21383 "\n"
21384 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21385 " left-hand edge of the viewport.\n"
21386 "\n"
21387 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21388 " right-hand edge of the viewport.\n"
21389 "\n"
21390 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21391 " bottom edge of the viewport.\n"
21392 "\n"
21393 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21394 " edge of the viewport.\n"
21395 "\n"
21396 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21397 " axis.\n"
21398 "\n"
21399 ""},
21400 { "plvpor", _wrap_plvpor, METH_VARARGS, "\n"
21401 "Specify viewport using normalized subpage coordinates\n"
21402 "\n"
21403 "DESCRIPTION:\n"
21404 "\n"
21405 " Device-independent routine for setting up the viewport. This defines\n"
21406 " the viewport in terms of normalized subpage coordinates which run from\n"
21407 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
21408 " current subpage. Use the alternate routine plsvpa in order to create\n"
21409 " a viewport of a definite size.\n"
21410 "\n"
21411 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
21412 "\n"
21413 " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
21414 " 24, 26, 27, and 31.\n"
21415 "\n"
21416 "\n"
21417 "\n"
21418 "SYNOPSIS:\n"
21419 "\n"
21420 "plvpor(xmin, xmax, ymin, ymax)\n"
21421 "\n"
21422 "ARGUMENTS:\n"
21423 "\n"
21424 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21425 " left-hand edge of the viewport.\n"
21426 "\n"
21427 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21428 " right-hand edge of the viewport.\n"
21429 "\n"
21430 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21431 " bottom edge of the viewport.\n"
21432 "\n"
21433 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21434 " edge of the viewport.\n"
21435 "\n"
21436 ""},
21437 { "plvsta", _wrap_plvsta, METH_NOARGS, "\n"
21438 "Select standard viewport\n"
21439 "\n"
21440 "DESCRIPTION:\n"
21441 "\n"
21442 " Selects the largest viewport within the subpage that leaves a standard\n"
21443 " margin (left-hand margin of eight character heights, and a margin\n"
21444 " around the other three sides of five character heights).\n"
21445 "\n"
21446 " Redacted form: plvsta()\n"
21447 "\n"
21448 " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
21449 "\n"
21450 "\n"
21451 "\n"
21452 "SYNOPSIS:\n"
21453 "\n"
21454 "plvsta()\n"
21455 "\n"
21456 ""},
21457 { "plw3d", _wrap_plw3d, METH_VARARGS, "\n"
21458 "Configure the transformations required for projecting a 3D surface on a 2D window\n"
21459 "\n"
21460 "DESCRIPTION:\n"
21461 "\n"
21462 " Configure the transformations required for projecting a 3D surface on\n"
21463 " an existing 2D window. Those transformations (see the PLplot\n"
21464 " documentation) are done to a rectangular cuboid enclosing the 3D\n"
21465 " surface which has its limits expressed in 3D world coordinates and\n"
21466 " also normalized 3D coordinates (used for interpreting the altitude and\n"
21467 " azimuth of the viewing angle). The transformations consist of the\n"
21468 " linear transform from 3D world coordinates to normalized 3D\n"
21469 " coordinates, and the 3D rotation of normalized coordinates required to\n"
21470 " align the pole of the new 3D coordinate system with the viewing\n"
21471 " direction specified by altitude and azimuth so that x and y of the\n"
21472 " surface elements in that transformed coordinate system are the\n"
21473 " projection of the 3D surface with given viewing direction on the 2D\n"
21474 " window.\n"
21475 "\n"
21476 " The enclosing rectangular cuboid for the surface plot is defined by\n"
21477 " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
21478 " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
21479 " sizes of basex by basey by height so that xmin maps to -\n"
21480 " basex/2, xmax maps to basex/2, ymin maps to -\n"
21481 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
21482 " The resulting rectangular cuboid in normalized coordinates is then\n"
21483 " viewed by an observer at altitude alt and azimuth az. This routine\n"
21484 " must be called before plbox3 or any of the 3D surface plotting\n"
21485 " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
21486 " plsurf3dl or plfill3.\n"
21487 "\n"
21488 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
21489 " zmin, zmax, alt, az)\n"
21490 "\n"
21491 " This function is examples 8, 11, 18, and 21.\n"
21492 "\n"
21493 "\n"
21494 "\n"
21495 "SYNOPSIS:\n"
21496 "\n"
21497 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
21498 "\n"
21499 "ARGUMENTS:\n"
21500 "\n"
21501 " basex (PLFLT, input) : The normalized x coordinate size of the\n"
21502 " rectangular cuboid.\n"
21503 "\n"
21504 " basey (PLFLT, input) : The normalized y coordinate size of the\n"
21505 " rectangular cuboid.\n"
21506 "\n"
21507 " height (PLFLT, input) : The normalized z coordinate size of the\n"
21508 " rectangular cuboid.\n"
21509 "\n"
21510 " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
21511 " rectangular cuboid.\n"
21512 "\n"
21513 " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
21514 " rectangular cuboid.\n"
21515 "\n"
21516 " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
21517 " rectangular cuboid.\n"
21518 "\n"
21519 " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
21520 " rectangular cuboid.\n"
21521 "\n"
21522 " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
21523 " rectangular cuboid.\n"
21524 "\n"
21525 " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
21526 " rectangular cuboid.\n"
21527 "\n"
21528 " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
21529 " plane of the rectangular cuboid in normalized coordinates.\n"
21530 "\n"
21531 " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
21532 " rectangular cuboid in normalized coordinates. When az=0, the\n"
21533 " observer is looking face onto the zx plane of the rectangular\n"
21534 " cuboid in normalized coordinates, and as az is increased, the\n"
21535 " observer moves clockwise around that cuboid when viewed from above\n"
21536 " the xy plane.\n"
21537 "\n"
21538 ""},
21539 { "plwidth", _wrap_plwidth, METH_O, "\n"
21540 "Set pen width\n"
21541 "\n"
21542 "DESCRIPTION:\n"
21543 "\n"
21544 " Sets the pen width.\n"
21545 "\n"
21546 " Redacted form: plwidth(width)\n"
21547 "\n"
21548 " This function is used in examples 1 and 2.\n"
21549 "\n"
21550 "\n"
21551 "\n"
21552 "SYNOPSIS:\n"
21553 "\n"
21554 "plwidth(width)\n"
21555 "\n"
21556 "ARGUMENTS:\n"
21557 "\n"
21558 " width (PLFLT, input) : The desired pen width. If width is negative\n"
21559 " or the same as the previous value no action is taken. width = 0.\n"
21560 " should be interpreted as as the minimum valid pen width for the\n"
21561 " device. The interpretation of positive width values is also\n"
21562 " device dependent.\n"
21563 "\n"
21564 ""},
21565 { "plwind", _wrap_plwind, METH_VARARGS, "\n"
21566 "Specify window\n"
21567 "\n"
21568 "DESCRIPTION:\n"
21569 "\n"
21570 " Specify the window, i.e., the world coordinates of the edges of the\n"
21571 " viewport.\n"
21572 "\n"
21573 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
21574 "\n"
21575 " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
21576 " 29, and 31.\n"
21577 "\n"
21578 "\n"
21579 "\n"
21580 "SYNOPSIS:\n"
21581 "\n"
21582 "plwind(xmin, xmax, ymin, ymax)\n"
21583 "\n"
21584 "ARGUMENTS:\n"
21585 "\n"
21586 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
21587 " of the viewport.\n"
21588 "\n"
21589 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
21590 " of the viewport.\n"
21591 "\n"
21592 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
21593 " the viewport.\n"
21594 "\n"
21595 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
21596 " viewport.\n"
21597 "\n"
21598 ""},
21599 { "plxormod", _wrap_plxormod, METH_O, "\n"
21600 "Enter or leave xor mode\n"
21601 "\n"
21602 "DESCRIPTION:\n"
21603 "\n"
21604 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
21605 " those drivers (e.g., the xwin driver) that support it. Enables\n"
21606 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
21607 " is not capable of xor operation it returns a status of false.\n"
21608 "\n"
21609 " Redacted form: plxormod(mode, status)\n"
21610 "\n"
21611 " This function is used in examples 1 and 20.\n"
21612 "\n"
21613 "\n"
21614 "\n"
21615 "SYNOPSIS:\n"
21616 "\n"
21617 "plxormod(mode, status)\n"
21618 "\n"
21619 "ARGUMENTS:\n"
21620 "\n"
21621 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
21622 " is false means leave xor mode.\n"
21623 "\n"
21624 " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
21625 " modestatus of true (false) means driver is capable (incapable) of\n"
21626 " xor mode.\n"
21627 "\n"
21628 ""},
21629 { "plmap", _wrap_plmap, METH_VARARGS, "\n"
21630 "Plot continental outline or shapefile data in world coordinates\n"
21631 "\n"
21632 "DESCRIPTION:\n"
21633 "\n"
21634 " Plots continental outlines or shapefile data in world coordinates. A\n"
21635 " demonstration of how to use this function to create different\n"
21636 " projections can be found in examples/c/x19c. PLplot is provided with\n"
21637 " basic coastal outlines and USA state borders. To use the map\n"
21638 " functionality PLplot must be compiled with the shapelib library.\n"
21639 " Shapefiles have become a popular standard for geographical data and\n"
21640 " data in this format can be easily found from a number of online\n"
21641 " sources. Shapefile data is actually provided as three or more files\n"
21642 " with the same filename, but different extensions. The .shp and .shx\n"
21643 " files are required for plotting Shapefile data with PLplot.\n"
21644 "\n"
21645 " PLplot currently supports the point, multipoint, polyline and polygon\n"
21646 " objects within shapefiles. However holes in polygons are not\n"
21647 " supported. When plmap is used the type of object is derived from the\n"
21648 " shapefile, if you wish to override the type then use one of the other\n"
21649 " plmap variants. The built in maps have line data only.\n"
21650 "\n"
21651 " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
21652 "\n"
21653 " This function is used in example 19.\n"
21654 "\n"
21655 "\n"
21656 "\n"
21657 "SYNOPSIS:\n"
21658 "\n"
21659 "plmap(mapform, name, minx, maxx, miny, maxy)\n"
21660 "\n"
21661 "ARGUMENTS:\n"
21662 "\n"
21663 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21664 " transform the original map data coordinates to a new coordinate\n"
21665 " system. The PLplot-supplied map data is provided as latitudes and\n"
21666 " longitudes; other Shapefile data may be provided in other\n"
21667 " coordinate systems as can be found in their .prj plain text files.\n"
21668 " For example, by using this transform we can change from a\n"
21669 " longitude, latitude coordinate to a polar stereographic\n"
21670 " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
21671 " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
21672 " corresponding y coordinates (latitudes for the PLplot supplied\n"
21673 " data). After the call to mapform(), x[] and y[] should be\n"
21674 " replaced by the corresponding plot coordinates. If no transform is\n"
21675 " desired, mapform can be replaced by NULL.\n"
21676 "\n"
21677 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21678 " the type of map plotted. This is either one of the PLplot built-in\n"
21679 " maps or the file name of a set of Shapefile files without the file\n"
21680 " extensions. For the PLplot built-in maps the possible values are:\n"
21681 " \"globe\" -- continental outlines\n"
21682 " \"usa\" -- USA and state boundaries\n"
21683 " \"cglobe\" -- continental outlines and countries\n"
21684 " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
21685 "\n"
21686 "\n"
21687 " minx (PLFLT, input) : The minimum x value of map elements to be\n"
21688 " drawn. The units must match the shapefile (built in maps are\n"
21689 " degrees lat/lon). Objects in the file which do not encroach on the\n"
21690 " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
21691 " note this is simply an optimisation, not a clipping so for objects\n"
21692 " with some points inside the box and some points outside the box\n"
21693 " all the points will be rendered. These parameters also define\n"
21694 " latitude and longitude wrapping for shapefiles using these units.\n"
21695 " Longitude points will be wrapped by integer multiples of 360\n"
21696 " degrees to place them in the box. This allows the same data to be\n"
21697 " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
21698 " you plot from -180-540 you will get two cycles of data drawn. The\n"
21699 " value of minx must be less than the value of maxx. Passing in a\n"
21700 " nan, max/-max floating point number or +/-infinity will case the\n"
21701 " bounding box from the shapefile to be used.\n"
21702 "\n"
21703 " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
21704 " drawn - see minx.\n"
21705 "\n"
21706 " miny (PLFLT, input) : The minimum y value of map elements to be\n"
21707 " drawn - see minx.\n"
21708 "\n"
21709 " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
21710 " drawn - see minx.\n"
21711 "\n"
21712 ""},
21713 { "plmapline", _wrap_plmapline, METH_VARARGS, "\n"
21714 "Plot all or a subset of Shapefile data using lines in world coordinates\n"
21715 "\n"
21716 "DESCRIPTION:\n"
21717 "\n"
21718 " Plot all or a subset of Shapefile data using lines in world\n"
21719 " coordinates. Our 19th standard example demonstrates how to use this\n"
21720 " function. This function plots data from a Shapefile using lines as in\n"
21721 " plmap, however it also has the option of also only drawing specified\n"
21722 " elements from the Shapefile. The vector of indices of the required\n"
21723 " elements are passed as a function argument. The Shapefile data should\n"
21724 " include a metadata file (extension.dbf) listing all items within the\n"
21725 " Shapefile. This file can be opened by most popular spreadsheet\n"
21726 " programs and can be used to decide which indices to pass to this\n"
21727 " function.\n"
21728 "\n"
21729 " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
21730 " plotentries)\n"
21731 "\n"
21732 " This function is used in example 19.\n"
21733 "\n"
21734 "\n"
21735 "\n"
21736 "SYNOPSIS:\n"
21737 "\n"
21738 "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21739 "\n"
21740 "ARGUMENTS:\n"
21741 "\n"
21742 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21743 " transform the coordinates given in the shapefile into a plot\n"
21744 " coordinate system. By using this transform, we can change from a\n"
21745 " longitude, latitude coordinate to a polar stereographic project,\n"
21746 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21747 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21748 " mapform(), x[] and y[] should be replaced by the corresponding\n"
21749 " plot coordinates. If no transform is desired, mapform can be\n"
21750 " replaced by NULL.\n"
21751 "\n"
21752 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21753 " the file name of a set of Shapefile files without the file\n"
21754 " extension.\n"
21755 "\n"
21756 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21757 " be in the same units as used by the Shapefile. You could use a\n"
21758 " very large negative number to plot everything, but you can improve\n"
21759 " performance by limiting the area drawn. The units must match those\n"
21760 " of the Shapefile projection, which may be for example longitude or\n"
21761 " distance. The value of minx must be less than the value of maxx.\n"
21762 "\n"
21763 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21764 " use a very large number to plot everything, but you can improve\n"
21765 " performance by limiting the area drawn.\n"
21766 "\n"
21767 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21768 " be in the same units as used by the Shapefile. You could use a\n"
21769 " very large negative number to plot everything, but you can improve\n"
21770 " performance by limiting the area drawn. The units must match those\n"
21771 " of the Shapefile projection, which may be for example latitude or\n"
21772 " distance. The value of miny must be less than the value of maxy.\n"
21773 "\n"
21774 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21775 " use a very large number to plot everything, but you can improve\n"
21776 " performance by limiting the area drawn.\n"
21777 "\n"
21778 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
21779 " zero-based indices of the Shapefile elements which will be drawn.\n"
21780 " Setting\n"
21781 " plotentries to NULL will plot all elements of the Shapefile.\n"
21782 "\n"
21783 " nplotentries (PLINT, input) : The number of items in\n"
21784 " plotentries. Ignored if\n"
21785 " plotentries is NULL.\n"
21786 "\n"
21787 ""},
21788 { "plmapstring", _wrap_plmapstring, METH_VARARGS, "\n"
21789 "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
21790 "\n"
21791 "DESCRIPTION:\n"
21792 "\n"
21793 " As per plmapline, however the items are plotted as strings or points\n"
21794 " in the same way as plstring.\n"
21795 "\n"
21796 " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
21797 " maxy, plotentries)\n"
21798 "\n"
21799 " This function is not used in any examples.\n"
21800 "\n"
21801 "\n"
21802 "\n"
21803 "SYNOPSIS:\n"
21804 "\n"
21805 "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21806 "\n"
21807 "ARGUMENTS:\n"
21808 "\n"
21809 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21810 " transform the coordinates given in the shapefile into a plot\n"
21811 " coordinate system. By using this transform, we can change from a\n"
21812 " longitude, latitude coordinate to a polar stereographic project,\n"
21813 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21814 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21815 " mapform(), x[] and y[] should be replaced by the corresponding\n"
21816 " plot coordinates. If no transform is desired, mapform can be\n"
21817 " replaced by NULL.\n"
21818 "\n"
21819 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21820 " the file name of a set of Shapefile files without the file\n"
21821 " extension.\n"
21822 "\n"
21823 " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
21824 " drawn.\n"
21825 "\n"
21826 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21827 " be in the same units as used by the Shapefile. You could use a\n"
21828 " very large negative number to plot everything, but you can improve\n"
21829 " performance by limiting the area drawn. The units must match those\n"
21830 " of the Shapefile projection, which may be for example longitude or\n"
21831 " distance. The value of minx must be less than the value of maxx.\n"
21832 "\n"
21833 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21834 " use a very large number to plot everything, but you can improve\n"
21835 " performance by limiting the area drawn.\n"
21836 "\n"
21837 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21838 " be in the same units as used by the Shapefile. You could use a\n"
21839 " very large negative number to plot everything, but you can improve\n"
21840 " performance by limiting the area drawn. The units must match those\n"
21841 " of the Shapefile projection, which may be for example latitude or\n"
21842 " distance. The value of miny must be less than the value of maxy.\n"
21843 "\n"
21844 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21845 " use a very large number to plot everything, but you can improve\n"
21846 " performance by limiting the area drawn.\n"
21847 "\n"
21848 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
21849 " zero-based indices of the Shapefile elements which will be drawn.\n"
21850 " Setting\n"
21851 " plotentries to NULL will plot all elements of the Shapefile.\n"
21852 "\n"
21853 " nplotentries (PLINT, input) : The number of items in\n"
21854 " plotentries. Ignored if\n"
21855 " plotentries is NULL.\n"
21856 "\n"
21857 ""},
21858 { "plmaptex", _wrap_plmaptex, METH_VARARGS, "\n"
21859 "Draw text at points defined by Shapefile data in world coordinates\n"
21860 "\n"
21861 "DESCRIPTION:\n"
21862 "\n"
21863 " As per plmapline, however the items are plotted as text in the same\n"
21864 " way as plptex.\n"
21865 "\n"
21866 " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
21867 " miny, maxy, plotentry)\n"
21868 "\n"
21869 " This function is used in example 19.\n"
21870 "\n"
21871 "\n"
21872 "\n"
21873 "SYNOPSIS:\n"
21874 "\n"
21875 "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
21876 "\n"
21877 "ARGUMENTS:\n"
21878 "\n"
21879 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21880 " transform the coordinates given in the shapefile into a plot\n"
21881 " coordinate system. By using this transform, we can change from a\n"
21882 " longitude, latitude coordinate to a polar stereographic project,\n"
21883 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21884 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21885 " mapform(), x[] and y[] should be replaced by the corresponding\n"
21886 " plot coordinates. If no transform is desired, mapform can be\n"
21887 " replaced by NULL.\n"
21888 "\n"
21889 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21890 " the file name of a set of Shapefile files without the file\n"
21891 " extension.\n"
21892 "\n"
21893 " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
21894 " dy/dx.\n"
21895 "\n"
21896 " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
21897 " dy/dx.\n"
21898 "\n"
21899 " just (PLFLT, input) : Set the justification of the text. The value\n"
21900 " given will be the fraction of the distance along the string that\n"
21901 " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
21902 " centralized text and 1.0 gives right aligned text.\n"
21903 "\n"
21904 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
21905 "\n"
21906 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21907 " be in the same units as used by the Shapefile. You could use a\n"
21908 " very large negative number to plot everything, but you can improve\n"
21909 " performance by limiting the area drawn. The units must match those\n"
21910 " of the Shapefile projection, which may be for example longitude or\n"
21911 " distance. The value of minx must be less than the value of maxx.\n"
21912 "\n"
21913 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21914 " use a very large number to plot everything, but you can improve\n"
21915 " performance by limiting the area drawn.\n"
21916 "\n"
21917 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21918 " be in the same units as used by the Shapefile. You could use a\n"
21919 " very large negative number to plot everything, but you can improve\n"
21920 " performance by limiting the area drawn. The units must match those\n"
21921 " of the Shapefile projection, which may be for example latitude or\n"
21922 " distance. The value of miny must be less than the value of maxy.\n"
21923 "\n"
21924 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21925 " use a very large number to plot everything, but you can improve\n"
21926 " performance by limiting the area drawn.\n"
21927 "\n"
21928 " plotentry (PLINT, input) : An integer indicating which text string\n"
21929 " of the Shapefile (zero indexed) will be drawn.\n"
21930 "\n"
21931 ""},
21932 { "plmapfill", _wrap_plmapfill, METH_VARARGS, "\n"
21933 "Plot all or a subset of Shapefile data, filling the polygons\n"
21934 "\n"
21935 "DESCRIPTION:\n"
21936 "\n"
21937 " As per plmapline, however the items are filled in the same way as\n"
21938 " plfill.\n"
21939 "\n"
21940 " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
21941 " plotentries)\n"
21942 "\n"
21943 " This function is used in example 19.\n"
21944 "\n"
21945 "\n"
21946 "\n"
21947 "SYNOPSIS:\n"
21948 "\n"
21949 "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
21950 "\n"
21951 "ARGUMENTS:\n"
21952 "\n"
21953 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21954 " transform the coordinates given in the shapefile into a plot\n"
21955 " coordinate system. By using this transform, we can change from a\n"
21956 " longitude, latitude coordinate to a polar stereographic project,\n"
21957 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
21958 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
21959 " mapform(), x[] and y[] should be replaced by the corresponding\n"
21960 " plot coordinates. If no transform is desired, mapform can be\n"
21961 " replaced by NULL.\n"
21962 "\n"
21963 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21964 " the file name of a set of Shapefile files without the file\n"
21965 " extension.\n"
21966 "\n"
21967 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
21968 " be in the same units as used by the Shapefile. You could use a\n"
21969 " very large negative number to plot everything, but you can improve\n"
21970 " performance by limiting the area drawn. The units must match those\n"
21971 " of the Shapefile projection, which may be for example longitude or\n"
21972 " distance. The value of minx must be less than the value of maxx.\n"
21973 "\n"
21974 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
21975 " use a very large number to plot everything, but you can improve\n"
21976 " performance by limiting the area drawn.\n"
21977 "\n"
21978 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
21979 " be in the same units as used by the Shapefile. You could use a\n"
21980 " very large negative number to plot everything, but you can improve\n"
21981 " performance by limiting the area drawn. The units must match those\n"
21982 " of the Shapefile projection, which may be for example latitude or\n"
21983 " distance. The value of miny must be less than the value of maxy.\n"
21984 "\n"
21985 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
21986 " use a very large number to plot everything, but you can improve\n"
21987 " performance by limiting the area drawn.\n"
21988 "\n"
21989 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
21990 " zero-based indices of the Shapefile elements which will be drawn.\n"
21991 " Setting\n"
21992 " plotentries to NULL will plot all elements of the Shapefile.\n"
21993 "\n"
21994 " nplotentries (PLINT, input) : The number of items in\n"
21995 " plotentries. Ignored if\n"
21996 " plotentries is NULL.\n"
21997 "\n"
21998 ""},
21999 { "plmeridians", _wrap_plmeridians, METH_VARARGS, "\n"
22000 "Plot latitude and longitude lines\n"
22001 "\n"
22002 "DESCRIPTION:\n"
22003 "\n"
22004 " Displays latitude and longitude on the current plot. The lines are\n"
22005 " plotted in the current color and line style.\n"
22006 "\n"
22007 " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22008 " minlat, maxlat)\n"
22009 "\n"
22010 " This function is used in example 19.\n"
22011 "\n"
22012 "\n"
22013 "\n"
22014 "SYNOPSIS:\n"
22015 "\n"
22016 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22017 "\n"
22018 "ARGUMENTS:\n"
22019 "\n"
22020 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22021 " transform the coordinate longitudes and latitudes to a plot\n"
22022 " coordinate system. By using this transform, we can change from a\n"
22023 " longitude, latitude coordinate to a polar stereographic project,\n"
22024 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22025 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22026 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22027 " plot coordinates. If no transform is desired, mapform can be\n"
22028 " replaced by NULL.\n"
22029 "\n"
22030 " dlong (PLFLT, input) : The interval in degrees at which the\n"
22031 " longitude lines are to be plotted.\n"
22032 "\n"
22033 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22034 " lines are to be plotted.\n"
22035 "\n"
22036 " minlong (PLFLT, input) : The value of the longitude on the left\n"
22037 " side of the plot. The value of minlong must be less than the value\n"
22038 " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22039 " equal to 360.\n"
22040 "\n"
22041 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22042 " side of the plot.\n"
22043 "\n"
22044 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22045 " background. One can always use -90.0 as the boundary outside the\n"
22046 " plot window will be automatically eliminated. However, the\n"
22047 " program will be faster if one can reduce the size of the\n"
22048 " background plotted.\n"
22049 "\n"
22050 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22051 " background. One can always use 90.0 as the boundary outside the\n"
22052 " plot window will be automatically eliminated.\n"
22053 "\n"
22054 ""},
22055 { "plimage", _wrap_plimage, METH_VARARGS, "\n"
22056 "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22057 "\n"
22058 "DESCRIPTION:\n"
22059 "\n"
22060 " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22061 " automatically adjusted to use the maximum and minimum values in idata\n"
22062 " as valuemin and valuemax in a call to plimagefr.\n"
22063 "\n"
22064 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22065 " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22066 "\n"
22067 "\n"
22068 " This function is used in example 20.\n"
22069 "\n"
22070 "\n"
22071 "\n"
22072 "SYNOPSIS:\n"
22073 "\n"
22074 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22075 "\n"
22076 "ARGUMENTS:\n"
22077 "\n"
22078 " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22079 " to plot. Should have dimensions of\n"
22080 " nx by\n"
22081 " ny.\n"
22082 "\n"
22083 " nx, ny (PLINT, input) : Dimensions of idata\n"
22084 "\n"
22085 " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22086 " are linearly transformed to these world coordinate ranges such\n"
22087 " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22088 " - 1] corresponds to (xmax, ymax).\n"
22089 "\n"
22090 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22091 " (inclusive) will be plotted.\n"
22092 "\n"
22093 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22094 " points whose plot coordinates fall inside the window of (Dxmin,\n"
22095 " Dymin) to (Dxmax, Dymax).\n"
22096 "\n"
22097 ""},
22098 { "plimagefr", _wrap_plimagefr, METH_VARARGS, "\n"
22099 "Plot a 2D matrix using cmap1\n"
22100 "\n"
22101 "DESCRIPTION:\n"
22102 "\n"
22103 " Plot a 2D matrix using cmap1.\n"
22104 "\n"
22105 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22106 " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22107 "\n"
22108 "\n"
22109 " This function is used in example 20.\n"
22110 "\n"
22111 "\n"
22112 "\n"
22113 "SYNOPSIS:\n"
22114 "\n"
22115 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22116 "\n"
22117 "ARGUMENTS:\n"
22118 "\n"
22119 " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22120 " plot. Should have dimensions of\n"
22121 " nx by\n"
22122 " ny.\n"
22123 "\n"
22124 " nx, ny (PLINT, input) : Dimensions of idata\n"
22125 "\n"
22126 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22127 " pltr below for how these arguments are used (only for the special case\n"
22128 " when the callback function\n"
22129 " pltr is not supplied).\n"
22130 "\n"
22131 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22132 " (inclusive) will be plotted.\n"
22133 "\n"
22134 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22135 " values to use for value to color mappings. A datum equal to or\n"
22136 " less than valuemin will be plotted with color 0.0, while a datum\n"
22137 " equal to or greater than valuemax will be plotted with color 1.0.\n"
22138 " Data between valuemin and valuemax map linearly to colors in the\n"
22139 " range (0.0-1.0).\n"
22140 "\n"
22141 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22142 " defines the transformation between the zero-based indices of the\n"
22143 " matrix idata and world coordinates. If\n"
22144 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22145 " indices of idata are mapped to the range\n"
22146 " xmin through\n"
22147 " xmax and the y indices of idata are mapped to the range\n"
22148 " ymin through\n"
22149 " ymax.For the C case, transformation functions are provided in the\n"
22150 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22151 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22152 " matrices. In addition, C callback routines for the transformation\n"
22153 " can be supplied by the user such as the mypltr function in\n"
22154 " examples/c/x09c.c which provides a general linear transformation\n"
22155 " between index coordinates and world coordinates.For languages\n"
22156 " other than C you should consult the PLplot documentation for the\n"
22157 " details concerning how PLTRANSFORM_callback arguments are\n"
22158 " interfaced. However, in general, a particular pattern of\n"
22159 " callback-associated arguments such as a tr vector with 6 elements;\n"
22160 " xg and yg vectors; or xg and yg matrices are respectively\n"
22161 " interfaced to a linear-transformation routine similar to the above\n"
22162 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22163 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22164 " support native language callbacks for handling index to\n"
22165 " world-coordinate transformations. Examples of these various\n"
22166 " approaches are given in examples/<language>x09*,\n"
22167 " examples/<language>x16*, examples/<language>x20*,\n"
22168 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22169 " supported languages.\n"
22170 "\n"
22171 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22172 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22173 " externally supplied.\n"
22174 "\n"
22175 ""},
22176 { "plClearOpts", _wrap_plClearOpts, METH_NOARGS, NULL},
22177 { "plResetOpts", _wrap_plResetOpts, METH_NOARGS, NULL},
22178 { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22179 { "plOptUsage", _wrap_plOptUsage, METH_NOARGS, NULL},
22180 { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_O, NULL},
22181 { "plGetCursor", _wrap_plGetCursor, METH_O, "\n"
22182 "Wait for graphics input event and translate to world coordinates.\n"
22183 "\n"
22184 "DESCRIPTION:\n"
22185 "\n"
22186 " Wait for graphics input event and translate to world coordinates.\n"
22187 " Returns 0 if no translation to world coordinates is possible.\n"
22188 "\n"
22189 " This function returns 1 on success and 0 if no translation to world\n"
22190 " coordinates is possible.\n"
22191 "\n"
22192 " Redacted form: plGetCursor(gin)\n"
22193 "\n"
22194 " This function is used in examples 1 and 20.\n"
22195 "\n"
22196 "\n"
22197 "\n"
22198 "SYNOPSIS:\n"
22199 "\n"
22200 "PLINT plGetCursor(gin)\n"
22201 "\n"
22202 "ARGUMENTS:\n"
22203 "\n"
22204 " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22205 " which will contain the output. The structure is not allocated by\n"
22206 " the routine and must exist before the function is called.\n"
22207 "\n"
22208 ""},
22209 { NULL, NULL, 0, NULL }
22210};
22211
22212static PyMethodDef SwigMethods_proxydocs[] = {
22213 { NULL, NULL, 0, NULL }
22214};
22215
22216
22217/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22218
22219static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22220static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22221static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22222static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22223static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
22224static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
22225static 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};
22226static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void = {"_p_f_int_double_p_char_int_p_void__void", "void (*)(int,double,char *,int,void *)|label_func", 0, 0, (void*)0, 0};
22227static 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};
22228static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void = {"_p_f_int_p_q_const__double_p_q_const__double__void", "void (*)(int,double const *,double const *)|fill_func", 0, 0, (void*)0, 0};
22229static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
22230static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22231static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22232static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
22233
22249};
22250
22251static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22252static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22253static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22254static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22255static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
22261static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22262static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
22263static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
22264static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22265
22281};
22282
22283
22284/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22285
22287{0, 0, 0, 0.0, 0, 0}};
22288
22289#ifdef __cplusplus
22290}
22291#endif
22292/* -----------------------------------------------------------------------------
22293 * Type initialization:
22294 * This problem is tough by the requirement that no dynamic
22295 * memory is used. Also, since swig_type_info structures store pointers to
22296 * swig_cast_info structures and swig_cast_info structures store pointers back
22297 * to swig_type_info structures, we need some lookup code at initialization.
22298 * The idea is that swig generates all the structures that are needed.
22299 * The runtime then collects these partially filled structures.
22300 * The SWIG_InitializeModule function takes these initial arrays out of
22301 * swig_module, and does all the lookup, filling in the swig_module.types
22302 * array with the correct data and linking the correct swig_cast_info
22303 * structures together.
22304 *
22305 * The generated swig_type_info structures are assigned statically to an initial
22306 * array. We just loop through that array, and handle each type individually.
22307 * First we lookup if this type has been already loaded, and if so, use the
22308 * loaded structure instead of the generated one. Then we have to fill in the
22309 * cast linked list. The cast data is initially stored in something like a
22310 * two-dimensional array. Each row corresponds to a type (there are the same
22311 * number of rows as there are in the swig_type_initial array). Each entry in
22312 * a column is one of the swig_cast_info structures for that type.
22313 * The cast_initial array is actually an array of arrays, because each row has
22314 * a variable number of columns. So to actually build the cast linked list,
22315 * we find the array of casts associated with the type, and loop through it
22316 * adding the casts to the list. The one last trick we need to do is making
22317 * sure the type pointer in the swig_cast_info struct is correct.
22318 *
22319 * First off, we lookup the cast->type name to see if it is already loaded.
22320 * There are three cases to handle:
22321 * 1) If the cast->type has already been loaded AND the type we are adding
22322 * casting info to has not been loaded (it is in this module), THEN we
22323 * replace the cast->type pointer with the type pointer that has already
22324 * been loaded.
22325 * 2) If BOTH types (the one we are adding casting info to, and the
22326 * cast->type) are loaded, THEN the cast info has already been loaded by
22327 * the previous module so we just ignore it.
22328 * 3) Finally, if cast->type has not already been loaded, then we add that
22329 * swig_cast_info to the linked list (because the cast->type) pointer will
22330 * be correct.
22331 * ----------------------------------------------------------------------------- */
22332
22333#ifdef __cplusplus
22334extern "C" {
22335#if 0
22336} /* c-mode */
22337#endif
22338#endif
22339
22340#if 0
22341#define SWIGRUNTIME_DEBUG
22342#endif
22343
22344
22345SWIGRUNTIME void
22346SWIG_InitializeModule(void *clientdata) {
22347 size_t i;
22348 swig_module_info *module_head, *iter;
22349 int init;
22350
22351 /* check to see if the circular list has been setup, if not, set it up */
22352 if (swig_module.next==0) {
22353 /* Initialize the swig_module */
22357 init = 1;
22358 } else {
22359 init = 0;
22360 }
22361
22362 /* Try and load any already created modules */
22363 module_head = SWIG_GetModule(clientdata);
22364 if (!module_head) {
22365 /* This is the first module loaded for this interpreter */
22366 /* so set the swig module into the interpreter */
22367 SWIG_SetModule(clientdata, &swig_module);
22368 } else {
22369 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
22370 iter=module_head;
22371 do {
22372 if (iter==&swig_module) {
22373 /* Our module is already in the list, so there's nothing more to do. */
22374 return;
22375 }
22376 iter=iter->next;
22377 } while (iter!= module_head);
22378
22379 /* otherwise we must add our module into the list */
22380 swig_module.next = module_head->next;
22381 module_head->next = &swig_module;
22382 }
22383
22384 /* When multiple interpreters are used, a module could have already been initialized in
22385 a different interpreter, but not yet have a pointer in this interpreter.
22386 In this case, we do not want to continue adding types... everything should be
22387 set up already */
22388 if (init == 0) return;
22389
22390 /* Now work on filling in swig_module.types */
22391#ifdef SWIGRUNTIME_DEBUG
22392 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
22393#endif
22394 for (i = 0; i < swig_module.size; ++i) {
22395 swig_type_info *type = 0;
22396 swig_type_info *ret;
22397 swig_cast_info *cast;
22398
22399#ifdef SWIGRUNTIME_DEBUG
22400 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
22401#endif
22402
22403 /* if there is another module already loaded */
22404 if (swig_module.next != &swig_module) {
22406 }
22407 if (type) {
22408 /* Overwrite clientdata field */
22409#ifdef SWIGRUNTIME_DEBUG
22410 printf("SWIG_InitializeModule: found type %s\n", type->name);
22411#endif
22414#ifdef SWIGRUNTIME_DEBUG
22415 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22416#endif
22417 }
22418 } else {
22419 type = swig_module.type_initial[i];
22420 }
22421
22422 /* Insert casting types */
22423 cast = swig_module.cast_initial[i];
22424 while (cast->type) {
22425 /* Don't need to add information already in the list */
22426 ret = 0;
22427#ifdef SWIGRUNTIME_DEBUG
22428 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22429#endif
22430 if (swig_module.next != &swig_module) {
22432#ifdef SWIGRUNTIME_DEBUG
22433 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22434#endif
22435 }
22436 if (ret) {
22437 if (type == swig_module.type_initial[i]) {
22438#ifdef SWIGRUNTIME_DEBUG
22439 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22440#endif
22441 cast->type = ret;
22442 ret = 0;
22443 } else {
22444 /* Check for casting already in the list */
22445 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22446#ifdef SWIGRUNTIME_DEBUG
22447 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22448#endif
22449 if (!ocast) ret = 0;
22450 }
22451 }
22452
22453 if (!ret) {
22454#ifdef SWIGRUNTIME_DEBUG
22455 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22456#endif
22457 if (type->cast) {
22458 type->cast->prev = cast;
22459 cast->next = type->cast;
22460 }
22461 type->cast = cast;
22462 }
22463 cast++;
22464 }
22465 /* Set entry in modules->types array equal to the type */
22466 swig_module.types[i] = type;
22467 }
22468 swig_module.types[i] = 0;
22469
22470#ifdef SWIGRUNTIME_DEBUG
22471 printf("**** SWIG_InitializeModule: Cast List ******\n");
22472 for (i = 0; i < swig_module.size; ++i) {
22473 int j = 0;
22475 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
22476 while (cast->type) {
22477 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22478 cast++;
22479 ++j;
22480 }
22481 printf("---- Total casts: %d\n",j);
22482 }
22483 printf("**** SWIG_InitializeModule: Cast List ******\n");
22484#endif
22485}
22486
22487/* This function will propagate the clientdata field of type to
22488* any new swig_type_info structures that have been added into the list
22489* of equivalent types. It is like calling
22490* SWIG_TypeClientData(type, clientdata) a second time.
22491*/
22492SWIGRUNTIME void
22494 size_t i;
22495 swig_cast_info *equiv;
22496 static int init_run = 0;
22497
22498 if (init_run) return;
22499 init_run = 1;
22500
22501 for (i = 0; i < swig_module.size; i++) {
22502 if (swig_module.types[i]->clientdata) {
22503 equiv = swig_module.types[i]->cast;
22504 while (equiv) {
22505 if (!equiv->converter) {
22506 if (equiv->type && !equiv->type->clientdata)
22508 }
22509 equiv = equiv->next;
22510 }
22511 }
22512 }
22513}
22514
22515#ifdef __cplusplus
22516#if 0
22517{
22518 /* c-mode */
22519#endif
22520}
22521#endif
22522
22523
22524
22525#ifdef __cplusplus
22526extern "C" {
22527#endif
22528
22529 /* Python-specific SWIG API */
22530#define SWIG_newvarlink() SWIG_Python_newvarlink()
22531#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
22532#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
22533
22534 /* -----------------------------------------------------------------------------
22535 * global variable support code.
22536 * ----------------------------------------------------------------------------- */
22537
22538 typedef struct swig_globalvar {
22539 char *name; /* Name of global variable */
22540 PyObject *(*get_attr)(void); /* Return the current value */
22541 int (*set_attr)(PyObject *); /* Set the value */
22544
22545 typedef struct swig_varlinkobject {
22546 PyObject_HEAD
22549
22550 SWIGINTERN PyObject *
22552#if PY_VERSION_HEX >= 0x03000000
22553 return PyUnicode_InternFromString("<Swig global variables>");
22554#else
22555 return PyString_FromString("<Swig global variables>");
22556#endif
22557 }
22558
22559 SWIGINTERN PyObject *
22561#if PY_VERSION_HEX >= 0x03000000
22562 PyObject *str = PyUnicode_InternFromString("(");
22563 PyObject *tail;
22564 PyObject *joined;
22565 swig_globalvar *var;
22566 for (var = v->vars; var; var=var->next) {
22567 tail = PyUnicode_FromString(var->name);
22568 joined = PyUnicode_Concat(str, tail);
22569 Py_DecRef(str);
22570 Py_DecRef(tail);
22571 str = joined;
22572 if (var->next) {
22573 tail = PyUnicode_InternFromString(", ");
22574 joined = PyUnicode_Concat(str, tail);
22575 Py_DecRef(str);
22576 Py_DecRef(tail);
22577 str = joined;
22578 }
22579 }
22580 tail = PyUnicode_InternFromString(")");
22581 joined = PyUnicode_Concat(str, tail);
22582 Py_DecRef(str);
22583 Py_DecRef(tail);
22584 str = joined;
22585#else
22586 PyObject *str = PyString_FromString("(");
22587 swig_globalvar *var;
22588 for (var = v->vars; var; var=var->next) {
22589 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
22590 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
22591 }
22592 PyString_ConcatAndDel(&str,PyString_FromString(")"));
22593#endif
22594 return str;
22595 }
22596
22597 SWIGINTERN void
22599 swig_globalvar *var = v->vars;
22600 while (var) {
22601 swig_globalvar *n = var->next;
22602 free(var->name);
22603 free(var);
22604 var = n;
22605 }
22606 }
22607
22608 SWIGINTERN PyObject *
22610 PyObject *res = NULL;
22611 swig_globalvar *var = v->vars;
22612 while (var) {
22613 if (strcmp(var->name,n) == 0) {
22614 res = (*var->get_attr)();
22615 break;
22616 }
22617 var = var->next;
22618 }
22619 if (res == NULL && !PyErr_Occurred()) {
22620 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
22621 }
22622 return res;
22623 }
22624
22625 SWIGINTERN int
22626 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
22627 int res = 1;
22628 swig_globalvar *var = v->vars;
22629 while (var) {
22630 if (strcmp(var->name,n) == 0) {
22631 res = (*var->set_attr)(p);
22632 break;
22633 }
22634 var = var->next;
22635 }
22636 if (res == 1 && !PyErr_Occurred()) {
22637 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
22638 }
22639 return res;
22640 }
22641
22642 SWIGINTERN PyTypeObject*
22644 static char varlink__doc__[] = "Swig var link object";
22645 static PyTypeObject varlink_type;
22646 static int type_init = 0;
22647 if (!type_init) {
22648 const PyTypeObject tmp = {
22649#if PY_VERSION_HEX >= 0x03000000
22650 PyVarObject_HEAD_INIT(NULL, 0)
22651#else
22652 PyObject_HEAD_INIT(NULL)
22653 0, /* ob_size */
22654#endif
22655 "swigvarlink", /* tp_name */
22656 sizeof(swig_varlinkobject), /* tp_basicsize */
22657 0, /* tp_itemsize */
22658 (destructor) swig_varlink_dealloc, /* tp_dealloc */
22659 0, /* tp_print */
22660 (getattrfunc) swig_varlink_getattr, /* tp_getattr */
22661 (setattrfunc) swig_varlink_setattr, /* tp_setattr */
22662 0, /* tp_compare */
22663 (reprfunc) swig_varlink_repr, /* tp_repr */
22664 0, /* tp_as_number */
22665 0, /* tp_as_sequence */
22666 0, /* tp_as_mapping */
22667 0, /* tp_hash */
22668 0, /* tp_call */
22669 (reprfunc) swig_varlink_str, /* tp_str */
22670 0, /* tp_getattro */
22671 0, /* tp_setattro */
22672 0, /* tp_as_buffer */
22673 0, /* tp_flags */
22674 varlink__doc__, /* tp_doc */
22675 0, /* tp_traverse */
22676 0, /* tp_clear */
22677 0, /* tp_richcompare */
22678 0, /* tp_weaklistoffset */
22679 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
22680 0, /* tp_del */
22681 0, /* tp_version_tag */
22682#if PY_VERSION_HEX >= 0x03040000
22683 0, /* tp_finalize */
22684#endif
22685#if PY_VERSION_HEX >= 0x03080000
22686 0, /* tp_vectorcall */
22687#endif
22688#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
22689 0, /* tp_print */
22690#endif
22691#ifdef COUNT_ALLOCS
22692 0, /* tp_allocs */
22693 0, /* tp_frees */
22694 0, /* tp_maxalloc */
22695 0, /* tp_prev */
22696 0 /* tp_next */
22697#endif
22698 };
22699 varlink_type = tmp;
22700 type_init = 1;
22701 if (PyType_Ready(&varlink_type) < 0)
22702 return NULL;
22703 }
22704 return &varlink_type;
22705 }
22706
22707 /* Create a variable linking object for use later */
22708 SWIGINTERN PyObject *
22710 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
22711 if (result) {
22712 result->vars = 0;
22713 }
22714 return ((PyObject*) result);
22715 }
22716
22717 SWIGINTERN void
22718 SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
22720 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
22721 if (gv) {
22722 size_t size = strlen(name)+1;
22723 gv->name = (char *)malloc(size);
22724 if (gv->name) {
22725 memcpy(gv->name, name, size);
22726 gv->get_attr = get_attr;
22727 gv->set_attr = set_attr;
22728 gv->next = v->vars;
22729 }
22730 }
22731 v->vars = gv;
22732 }
22733
22734 SWIGINTERN PyObject *
22736 static PyObject *globals = 0;
22737 if (!globals) {
22738 globals = SWIG_newvarlink();
22739 }
22740 return globals;
22741 }
22742
22743 /* -----------------------------------------------------------------------------
22744 * constants/methods manipulation
22745 * ----------------------------------------------------------------------------- */
22746
22747 /* Install Constants */
22748 SWIGINTERN void
22750 PyObject *obj = 0;
22751 size_t i;
22752 for (i = 0; constants[i].type; ++i) {
22753 switch(constants[i].type) {
22754 case SWIG_PY_POINTER:
22755 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22756 break;
22757 case SWIG_PY_BINARY:
22758 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22759 break;
22760 default:
22761 obj = 0;
22762 break;
22763 }
22764 if (obj) {
22765 PyDict_SetItemString(d, constants[i].name, obj);
22766 Py_DECREF(obj);
22767 }
22768 }
22769 }
22770
22771 /* -----------------------------------------------------------------------------*/
22772 /* Fix SwigMethods to carry the callback ptrs when needed */
22773 /* -----------------------------------------------------------------------------*/
22774
22775 SWIGINTERN void
22776 SWIG_Python_FixMethods(PyMethodDef *methods,
22777 swig_const_info *const_table,
22778 swig_type_info **types,
22779 swig_type_info **types_initial) {
22780 size_t i;
22781 for (i = 0; methods[i].ml_name; ++i) {
22782 const char *c = methods[i].ml_doc;
22783 if (!c) continue;
22784 c = strstr(c, "swig_ptr: ");
22785 if (c) {
22786 int j;
22787 swig_const_info *ci = 0;
22788 const char *name = c + 10;
22789 for (j = 0; const_table[j].type; ++j) {
22790 if (strncmp(const_table[j].name, name,
22791 strlen(const_table[j].name)) == 0) {
22792 ci = &(const_table[j]);
22793 break;
22794 }
22795 }
22796 if (ci) {
22797 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
22798 if (ptr) {
22799 size_t shift = (ci->ptype) - types;
22800 swig_type_info *ty = types_initial[shift];
22801 size_t ldoc = (c - methods[i].ml_doc);
22802 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22803 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22804 if (ndoc) {
22805 char *buff = ndoc;
22806 memcpy(buff, methods[i].ml_doc, ldoc);
22807 buff += ldoc;
22808 memcpy(buff, "swig_ptr: ", 10);
22809 buff += 10;
22810 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22811 methods[i].ml_doc = ndoc;
22812 }
22813 }
22814 }
22815 }
22816 }
22817 }
22818
22819 /* -----------------------------------------------------------------------------
22820 * Method creation and docstring support functions
22821 * ----------------------------------------------------------------------------- */
22822
22823 /* -----------------------------------------------------------------------------
22824 * Function to find the method definition with the correct docstring for the
22825 * proxy module as opposed to the low-level API
22826 * ----------------------------------------------------------------------------- */
22827
22828 SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
22829 /* Find the function in the modified method table */
22830 size_t offset = 0;
22831 int found = 0;
22832 while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
22833 if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
22834 found = 1;
22835 break;
22836 }
22837 offset++;
22838 }
22839 /* Use the copy with the modified docstring if available */
22840 return found ? &SwigMethods_proxydocs[offset] : NULL;
22841 }
22842
22843 /* -----------------------------------------------------------------------------
22844 * Wrapper of PyInstanceMethod_New() used in Python 3
22845 * It is exported to the generated module, used for -fastproxy
22846 * ----------------------------------------------------------------------------- */
22847
22848 SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
22849 if (PyCFunction_Check(func)) {
22850 PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
22851 PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
22852 if (ml)
22853 func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
22854 }
22855#if PY_VERSION_HEX >= 0x03000000
22856 return PyInstanceMethod_New(func);
22857#else
22858 return PyMethod_New(func, NULL, NULL);
22859#endif
22860 }
22861
22862 /* -----------------------------------------------------------------------------
22863 * Wrapper of PyStaticMethod_New()
22864 * It is exported to the generated module, used for -fastproxy
22865 * ----------------------------------------------------------------------------- */
22866
22867 SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
22868 if (PyCFunction_Check(func)) {
22869 PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
22870 PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
22871 if (ml)
22872 func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
22873 }
22874 return PyStaticMethod_New(func);
22875 }
22876
22877#ifdef __cplusplus
22878}
22879#endif
22880
22881/* -----------------------------------------------------------------------------*
22882 * Partial Init method
22883 * -----------------------------------------------------------------------------*/
22884
22885#ifdef __cplusplus
22886extern "C"
22887#endif
22888
22890#if PY_VERSION_HEX >= 0x03000000
22891PyObject*
22892#else
22893void
22894#endif
22895SWIG_init(void) {
22896 PyObject *m, *d, *md, *globals;
22897
22898#if PY_VERSION_HEX >= 0x03000000
22899 static struct PyModuleDef SWIG_module = {
22900 PyModuleDef_HEAD_INIT,
22901 SWIG_name,
22902 NULL,
22903 -1,
22905 NULL,
22906 NULL,
22907 NULL,
22908 NULL
22909 };
22910#endif
22911
22912#if defined(SWIGPYTHON_BUILTIN)
22913 static SwigPyClientData SwigPyObject_clientdata = {
22914 0, 0, 0, 0, 0, 0, 0
22915 };
22916 static PyGetSetDef this_getset_def = {
22917 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
22918 };
22919 static SwigPyGetSet thisown_getset_closure = {
22922 };
22923 static PyGetSetDef thisown_getset_def = {
22924 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
22925 };
22926 PyTypeObject *builtin_pytype;
22927 int builtin_base_count;
22928 swig_type_info *builtin_basetype;
22929 PyObject *tuple;
22930 PyGetSetDescrObject *static_getset;
22931 PyTypeObject *metatype;
22932 PyTypeObject *swigpyobject;
22933 SwigPyClientData *cd;
22934 PyObject *public_interface, *public_symbol;
22935 PyObject *this_descr;
22936 PyObject *thisown_descr;
22937 PyObject *self = 0;
22938 int i;
22939
22940 (void)builtin_pytype;
22941 (void)builtin_base_count;
22942 (void)builtin_basetype;
22943 (void)tuple;
22944 (void)static_getset;
22945 (void)self;
22946
22947 /* Metaclass is used to implement static member variables */
22948 metatype = SwigPyObjectType();
22949 assert(metatype);
22950#endif
22951
22952 (void)globals;
22953
22954 /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
22955 SWIG_This();
22958#ifndef SWIGPYTHON_BUILTIN
22960#endif
22961
22962 /* Fix SwigMethods to carry the callback ptrs when needed */
22964
22965#if PY_VERSION_HEX >= 0x03000000
22966 m = PyModule_Create(&SWIG_module);
22967#else
22968 m = Py_InitModule(SWIG_name, SwigMethods);
22969#endif
22970
22971 md = d = PyModule_GetDict(m);
22972 (void)md;
22973
22975
22976#ifdef SWIGPYTHON_BUILTIN
22977 swigpyobject = SwigPyObject_TypeOnce();
22978
22979 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
22980 assert(SwigPyObject_stype);
22981 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
22982 if (!cd) {
22983 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
22984 SwigPyObject_clientdata.pytype = swigpyobject;
22985 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
22986 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
22987# if PY_VERSION_HEX >= 0x03000000
22988 return NULL;
22989# else
22990 return;
22991# endif
22992 }
22993
22994 /* All objects have a 'this' attribute */
22995 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
22996 (void)this_descr;
22997
22998 /* All objects have a 'thisown' attribute */
22999 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23000 (void)thisown_descr;
23001
23002 public_interface = PyList_New(0);
23003 public_symbol = 0;
23004 (void)public_symbol;
23005
23006 PyDict_SetItemString(md, "__all__", public_interface);
23007 Py_DECREF(public_interface);
23008 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23009 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23010 for (i = 0; swig_const_table[i].name != 0; ++i)
23011 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23012#endif
23013
23015
23016
23017 import_array();
23018
23019 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23020 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23021 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23022 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23023 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23024 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23025 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23026 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23027 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23028 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23029 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23030 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23031 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23032 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23033 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23034 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23035 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23036 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23037 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23038 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23039 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23040 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23041 SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23042 SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23043 SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23044 SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23045 SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23046 SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23047 SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23048 SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23049 SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23050 SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23051 SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23052 SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23053 SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23054 SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23055 SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23056 SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23057 SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23058 SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23059 SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23060 SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23061 SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23062 SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23063 SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23064 SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23065 SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23066 SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23067 SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23068 SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23069 SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23070 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23071 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23072 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23073 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23074 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23075 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23076 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23077 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23078 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23079 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23080 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23081 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23082 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23083 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23084 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23085 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23086 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23087 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23088 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23089 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23090 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23091 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23092 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23093 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23094 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23095 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23096 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23097 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23098 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23099 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23100 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23101 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23102 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23103 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23104 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23105 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23106 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23107 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23108 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23109 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23110 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23111 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23112 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23113 SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23114 SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23115 SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23116 SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23117 SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23118 SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23119 SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23120 SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23121 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23122 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23123 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23124 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23125 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23126 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23127 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23128 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL0",SWIG_From_int((int)(16)));
23129 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL1",SWIG_From_int((int)(128)));
23130 SWIG_Python_SetConstant(d, "MIN_PLINT_RGB",SWIG_From_int((int)(0)));
23131 SWIG_Python_SetConstant(d, "MAX_PLINT_RGB",SWIG_From_int((int)(255)));
23132 SWIG_Python_SetConstant(d, "MIN_PLFLT_CMAP1",SWIG_From_double((double)(0.)));
23133 SWIG_Python_SetConstant(d, "MAX_PLFLT_CMAP1",SWIG_From_double((double)(1.)));
23134 SWIG_Python_SetConstant(d, "MIN_PLFLT_ALPHA",SWIG_From_double((double)(0.)));
23135 SWIG_Python_SetConstant(d, "MAX_PLFLT_ALPHA",SWIG_From_double((double)(1.)));
23136 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23137 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23138 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23139 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23140 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23141 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23142 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23143 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23144 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23145 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23146 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23147 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23148 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23149 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23150 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23151 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23152 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23153 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23154 SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23155 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23156 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23157 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23158 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23159 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23160 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23161 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23162 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23163 SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23164 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23165 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23166 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23167 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23168 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23169 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23170 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23171 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23172 SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23173 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23174 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23175 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23176 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23177 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23178 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23179 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23180 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23181 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23182 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23183 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23184 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23185 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23186 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23187 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23188 SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23189 SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23190 SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23191 SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23192 SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23193 SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23194 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23195 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23196 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23197 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23198 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23199 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23200 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23201 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23202 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23203 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23204#if PY_VERSION_HEX >= 0x03000000
23205 return m;
23206#else
23207 return;
23208#endif
23209}
23210
integer(kind=private_plint), parameter, private maxlen
Definition: plplot.f90:48
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 plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plmap.c:639
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:616
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:661
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
void plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:594
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 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 plcol1
Definition: plplot.h:703
#define pltimefmt
Definition: plplot.h:856
PLUINT PLUNICODE
Definition: plplot.h:201
#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 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 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 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
int min(int a, int b)
int max(int a, int b)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info * swig_cast_initial[]
static PLcGrid2 tmpGrid2
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
#define SWIG_MangledTypeQuery(name)
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsmema(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PLcGrid tmpGrid1
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
@ CB_Python
static PyObject * Swig_This_global
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_PLcGrid2[]
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
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TypeQuery(name)
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_POINTER_OWN
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_SyntaxError
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_POINTER_NEW
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CheckState(r)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_f_double_double__int[]
void cleanup_mapform(void)
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_int[]
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
#define SWIG_BUFFER_SIZE
#define SWIG_TypeError
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PLINT Alen
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define myArray_ContiguousFromObject
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
#define SWIG_POINTER_IMPLICIT_CONV
static swig_cast_info _swigc__p_double[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGTYPE_p_PLGraphicsIn
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
#define SWIG_PY_POINTER
struct swig_cast_info swig_cast_info
#define SWIG_init
SWIGINTERN int swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p)
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)
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_PYTHON_THREAD_END_BLOCK
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_RuntimeError
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * swig_varlink_getattr(swig_varlinkobject *v, char *n)
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
struct swig_varlinkobject swig_varlinkobject
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_NewClientData(obj)
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
mapform_func marshal_mapform(PyObject *input)
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define PyObject_DEL
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * swig_varlink_str(swig_varlinkobject *v)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
#define SWIGRUNTIME
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_PY_BINARY
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_as_voidptrptr(a)
PyObject * python_f2eval
#define SWIG_RUNTIME_VERSION
SWIGINTERN char * SWIG_Python_str_AsChar(PyObject *str)
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
SWIGINTERN PyObject * _wrap_plimage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_POINTER_NOSHADOW
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_OLDOBJ
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
#define SWIG_ValueError
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
#define t_output_helper
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyMethodDef swigobject_methods[]
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_AddCast(r)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void cleanup_PLcGrid1(void)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
SWIGINTERN PyObject * _wrap_pltr2(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IsNewObj(r)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_InternalNewPointerObj(ptr, type, flags)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define NPY_PLFLT
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
#define SWIG_exception_fail(code, msg)
void cleanup_ct(void)
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
#define SWIG_AttributeError
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_module_info swig_module
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PLINT Ylen
static swig_type_info _swigt__p_double
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(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_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
SWIGINTERN PyTypeObject * swig_varlink_type(void)
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGUNUSEDPARM(p)
PLPointer marshal_PLPointer(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(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))
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
static swig_type_info _swigt__p_p_char
#define SWIG_Python_CallFunctor(functor, obj)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
static swig_type_info _swigt__p_p_double
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
PyObject * python_label
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_const_info swig_const_info
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_newvarlink()
SWIGRUNTIME void SWIG_Python_RaiseOrModifyTypeError(const char *message)
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
#define SWIG_Python_str_DelForPy3(x)
static swig_cast_info _swigc__p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(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_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
void cleanup_pltr(void)
void cleanup_PLcGrid2(void)
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_p_double[]
#define SWIGINTERN
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
#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_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(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
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_NewPointerObj(ptr, type, flags)
SWIGINTERN PyObject * _wrap_pltr1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
ct_func marshal_ct(PyObject *input)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_POINTER_NO_NULL
#define SWIG_Python_str_FromFormat
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_InstallConstants(d, constants)
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info *(* swig_dycast_func)(void **)
#define SWIG_IOError
static PyMethodDef SwigMethods[]
#define SWIG_NullReferenceError
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(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_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_STATIC_POINTER(var)
struct swig_type_info swig_type_info
PyObject * python_mapform
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
static swig_type_info _swigt__p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IsTmpObj(r)
static swig_type_info _swigt__p_f_double_double__int
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
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_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TMPOBJ
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(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_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_NewPackedObj(ptr, sz, type)
static swig_cast_info _swigc__p_PLcGrid[]
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_GetModule(clientdata)
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)
SWIGRUNTIME void SWIG_PropagateClientData(void)
PyArrayObject * pltr_xg
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(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_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static PyMethodDef SwigMethods_proxydocs[]
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyObject * SWIG_This(void)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj)
#define SWIG_TYPE_TABLE_NAME
static swig_type_info _swigt__p_PLcGrid
#define SWIG_BUILTIN_TP_INIT
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_unsigned_int
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CAST_NEW_MEMORY
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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 int SWIG_AsVal_long(PyObject *obj, long *val)
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
PyArrayObject * pltr_yg
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_module_info swig_module_info
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PyObject * python_ct
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(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)
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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 void swig_varlink_dealloc(swig_varlinkobject *v)
SWIGINTERN PyObject * swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v))
static swig_type_info * swig_type_initial[]
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
SWIGINTERN PyObject * _wrap_plsmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define PySequence_Fast_GET_ITEM
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
static swig_cast_info _swigc__p_p_char[]
#define PySequence_Size
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_MemoryError
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_SystemError
#define SWIG_DivisionByZero
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIGTYPE_p_double
static swig_type_info _swigt__p_char
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
#define SWIG_OverflowError
#define SWIGEXPORT
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IsOK(r)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_PLcGrid2
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IndexError
SWIGINTERN PyObject * _wrap_pltr0(PyObject *SWIGUNUSEDPARM(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_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(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)
#define SWIG_AddNewMask(r)
SWIGINTERN PyObject * SWIG_globals(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyMethodDef * SWIG_PythonGetProxyDoc(const char *name)
#define SWIG_OK
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#define SWIGINTERNINLINE
enum callback_type pltr_type
#define Py_TYPE(op)
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define MY_UNBLOCK_THREADS
#define SWIGRUNTIMEINLINE
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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
PyTypeObject * pytype
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