PLplot 5.15.0
Loading...
Searching...
No Matches
plplotcPYTHON_wrap.c
Go to the documentation of this file.
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (https://www.swig.org).
3 * Version 4.1.1
4 *
5 * Do not make changes to this file unless you know what you are doing - modify
6 * the SWIG interface file instead.
7 * ----------------------------------------------------------------------------- */
8
9
10#define SWIG_VERSION 0x040101
11#define SWIGPYTHON
12#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14/* -----------------------------------------------------------------------------
15 * This section contains generic SWIG labels for method/variable
16 * declarations/attributes, and other compiler dependent labels.
17 * ----------------------------------------------------------------------------- */
18
19/* template workaround for compilers that cannot correctly implement the C++ standard */
20#ifndef SWIGTEMPLATEDISAMBIGUATOR
21# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
22# define SWIGTEMPLATEDISAMBIGUATOR template
23# elif defined(__HP_aCC)
24/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
25/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
26# define SWIGTEMPLATEDISAMBIGUATOR template
27# else
28# define SWIGTEMPLATEDISAMBIGUATOR
29# endif
30#endif
31
32/* inline attribute */
33#ifndef SWIGINLINE
34# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
35# define SWIGINLINE inline
36# else
37# define SWIGINLINE
38# endif
39#endif
40
41/* attribute recognised by some compilers to avoid 'unused' warnings */
42#ifndef SWIGUNUSED
43# if defined(__GNUC__)
44# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
45# define SWIGUNUSED __attribute__ ((__unused__))
46# else
47# define SWIGUNUSED
48# endif
49# elif defined(__ICC)
50# define SWIGUNUSED __attribute__ ((__unused__))
51# else
52# define SWIGUNUSED
53# endif
54#endif
55
56#ifndef SWIG_MSC_UNSUPPRESS_4505
57# if defined(_MSC_VER)
58# pragma warning(disable : 4505) /* unreferenced local function has been removed */
59# endif
60#endif
61
62#ifndef SWIGUNUSEDPARM
63# ifdef __cplusplus
64# define SWIGUNUSEDPARM(p)
65# else
66# define SWIGUNUSEDPARM(p) p SWIGUNUSED
67# endif
68#endif
69
70/* internal SWIG method */
71#ifndef SWIGINTERN
72# define SWIGINTERN static SWIGUNUSED
73#endif
74
75/* internal inline SWIG method */
76#ifndef SWIGINTERNINLINE
77# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
78#endif
79
80/* exporting methods */
81#if defined(__GNUC__)
82# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
83# ifndef GCC_HASCLASSVISIBILITY
84# define GCC_HASCLASSVISIBILITY
85# endif
86# endif
87#endif
88
89#ifndef SWIGEXPORT
90# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
91# if defined(STATIC_LINKED)
92# define SWIGEXPORT
93# else
94# define SWIGEXPORT __declspec(dllexport)
95# endif
96# else
97# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
98# define SWIGEXPORT __attribute__ ((visibility("default")))
99# else
100# define SWIGEXPORT
101# endif
102# endif
103#endif
104
105/* calling conventions for Windows */
106#ifndef SWIGSTDCALL
107# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
108# define SWIGSTDCALL __stdcall
109# else
110# define SWIGSTDCALL
111# endif
112#endif
113
114/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
115#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
116# define _CRT_SECURE_NO_DEPRECATE
117#endif
118
119/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
120#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
121# define _SCL_SECURE_NO_DEPRECATE
122#endif
123
124/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
125#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
126# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
127#endif
128
129/* Intel's compiler complains if a variable which was never initialised is
130 * cast to void, which is a common idiom which we use to indicate that we
131 * are aware a variable isn't used. So we just silence that warning.
132 * See: https://github.com/swig/swig/issues/192 for more discussion.
133 */
134#ifdef __INTEL_COMPILER
135# pragma warning disable 592
136#endif
137
138
139#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
140/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
141# include <math.h>
142#endif
143
144#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
145#define PY_SSIZE_T_CLEAN
146#endif
147
148#if __GNUC__ >= 7
149#pragma GCC diagnostic push
150#if defined(__cplusplus) && __cplusplus >=201703L
151#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
152#endif
153#endif
154
155#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
156/* Use debug wrappers with the Python release dll */
157
158#if defined(_MSC_VER) && _MSC_VER >= 1929
159/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
160 * See https://github.com/swig/swig/issues/2090 */
161# include <corecrt.h>
162#endif
163
164# undef _DEBUG
165# include <Python.h>
166# define _DEBUG 1
167#else
168# include <Python.h>
169#endif
170
171#if __GNUC__ >= 7
172#pragma GCC diagnostic pop
173#endif
174
175/* -----------------------------------------------------------------------------
176 * swigrun.swg
177 *
178 * This file contains generic C API SWIG runtime support for pointer
179 * type checking.
180 * ----------------------------------------------------------------------------- */
181
182/* This should only be incremented when either the layout of swig_type_info changes,
183 or for whatever reason, the runtime changes incompatibly */
184#define SWIG_RUNTIME_VERSION "4"
185
186/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
187#ifdef SWIG_TYPE_TABLE
188# define SWIG_QUOTE_STRING(x) #x
189# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
190# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
191#else
192# define SWIG_TYPE_TABLE_NAME
193#endif
194
195/*
196 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
197 creating a static or dynamic library from the SWIG runtime code.
198 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
199
200 But only do this if strictly necessary, ie, if you have problems
201 with your compiler or suchlike.
202*/
203
204#ifndef SWIGRUNTIME
205# define SWIGRUNTIME SWIGINTERN
206#endif
207
208#ifndef SWIGRUNTIMEINLINE
209# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
210#endif
211
212/* Generic buffer size */
213#ifndef SWIG_BUFFER_SIZE
214# define SWIG_BUFFER_SIZE 1024
215#endif
216
217/* Flags for pointer conversions */
218#define SWIG_POINTER_DISOWN 0x1
219#define SWIG_CAST_NEW_MEMORY 0x2
220#define SWIG_POINTER_NO_NULL 0x4
221#define SWIG_POINTER_CLEAR 0x8
222#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
223
224/* Flags for new pointer objects */
225#define SWIG_POINTER_OWN 0x1
226
227
228/*
229 Flags/methods for returning states.
230
231 The SWIG conversion methods, as ConvertPtr, return an integer
232 that tells if the conversion was successful or not. And if not,
233 an error code can be returned (see swigerrors.swg for the codes).
234
235 Use the following macros/flags to set or process the returning
236 states.
237
238 In old versions of SWIG, code such as the following was usually written:
239
240 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
241 // success code
242 } else {
243 //fail code
244 }
245
246 Now you can be more explicit:
247
248 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
249 if (SWIG_IsOK(res)) {
250 // success code
251 } else {
252 // fail code
253 }
254
255 which is the same really, but now you can also do
256
257 Type *ptr;
258 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
259 if (SWIG_IsOK(res)) {
260 // success code
261 if (SWIG_IsNewObj(res) {
262 ...
263 delete *ptr;
264 } else {
265 ...
266 }
267 } else {
268 // fail code
269 }
270
271 I.e., now SWIG_ConvertPtr can return new objects and you can
272 identify the case and take care of the deallocation. Of course that
273 also requires SWIG_ConvertPtr to return new result values, such as
274
275 int SWIG_ConvertPtr(obj, ptr,...) {
276 if (<obj is ok>) {
277 if (<need new object>) {
278 *ptr = <ptr to new allocated object>;
279 return SWIG_NEWOBJ;
280 } else {
281 *ptr = <ptr to old object>;
282 return SWIG_OLDOBJ;
283 }
284 } else {
285 return SWIG_BADOBJ;
286 }
287 }
288
289 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
290 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
291 SWIG errors code.
292
293 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
294 allows returning the 'cast rank', for example, if you have this
295
296 int food(double)
297 int fooi(int);
298
299 and you call
300
301 food(1) // cast rank '1' (1 -> 1.0)
302 fooi(1) // cast rank '0'
303
304 just use the SWIG_AddCast()/SWIG_CheckState()
305*/
306
307#define SWIG_OK (0)
308/* Runtime errors are < 0 */
309#define SWIG_ERROR (-1)
310/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
311/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
312/* Errors < -200 are generic runtime specific errors */
313#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
314
315#define SWIG_IsOK(r) (r >= 0)
316#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
317
318/* The CastRankLimit says how many bits are used for the cast rank */
319#define SWIG_CASTRANKLIMIT (1 << 8)
320/* The NewMask denotes the object was created (using new/malloc) */
321#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
322/* The TmpMask is for in/out typemaps that use temporal objects */
323#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
324/* Simple returning values */
325#define SWIG_BADOBJ (SWIG_ERROR)
326#define SWIG_OLDOBJ (SWIG_OK)
327#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
328#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
329/* Check, add and del object mask methods */
330#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
331#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
332#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
333#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
334#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
335#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
336
337/* Cast-Rank Mode */
338#if defined(SWIG_CASTRANK_MODE)
339# ifndef SWIG_TypeRank
340# define SWIG_TypeRank unsigned long
341# endif
342# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
343# define SWIG_MAXCASTRANK (2)
344# endif
345# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
346# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
348 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
349}
351 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
352}
353#else /* no cast-rank mode */
354# define SWIG_AddCast(r) (r)
355# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
356#endif
357
358
359#include <string.h>
360
361#ifdef __cplusplus
362extern "C" {
363#endif
364
365typedef void *(*swig_converter_func)(void *, int *);
366typedef struct swig_type_info *(*swig_dycast_func)(void **);
367
368/* Structure to store information on one type */
369typedef struct swig_type_info {
370 const char *name; /* mangled name of this type */
371 const char *str; /* human readable name of this type */
372 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
373 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
374 void *clientdata; /* language specific type data */
375 int owndata; /* flag if the structure owns the clientdata */
377
378/* Structure to store a type and conversion function used for casting */
379typedef struct swig_cast_info {
380 swig_type_info *type; /* pointer to type that is equivalent to this type */
381 swig_converter_func converter; /* function to cast the void pointers */
382 struct swig_cast_info *next; /* pointer to next cast in linked list */
383 struct swig_cast_info *prev; /* pointer to the previous cast */
385
386/* Structure used to store module information
387 * Each module generates one structure like this, and the runtime collects
388 * all of these structures and stores them in a circularly linked list.*/
389typedef struct swig_module_info {
390 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
391 size_t size; /* Number of types in this module */
392 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
393 swig_type_info **type_initial; /* Array of initially generated type structures */
394 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
395 void *clientdata; /* Language specific module data */
397
398/*
399 Compare two type names skipping the space characters, therefore
400 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
401
402 Return 0 when the two name types are equivalent, as in
403 strncmp, but skipping ' '.
404*/
405SWIGRUNTIME int
406SWIG_TypeNameComp(const char *f1, const char *l1,
407 const char *f2, const char *l2) {
408 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
409 while ((*f1 == ' ') && (f1 != l1)) ++f1;
410 while ((*f2 == ' ') && (f2 != l2)) ++f2;
411 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
412 }
413 return (int)((l1 - f1) - (l2 - f2));
414}
415
416/*
417 Check type equivalence in a name list like <name1>|<name2>|...
418 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
419*/
420SWIGRUNTIME int
421SWIG_TypeCmp(const char *nb, const char *tb) {
422 int equiv = 1;
423 const char* te = tb + strlen(tb);
424 const char* ne = nb;
425 while (equiv != 0 && *ne) {
426 for (nb = ne; *ne; ++ne) {
427 if (*ne == '|') break;
428 }
429 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
430 if (*ne) ++ne;
431 }
432 return equiv;
433}
434
435/*
436 Check type equivalence in a name list like <name1>|<name2>|...
437 Return 0 if not equal, 1 if equal
438*/
439SWIGRUNTIME int
440SWIG_TypeEquiv(const char *nb, const char *tb) {
441 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
442}
443
444/*
445 Check the typename
446*/
448SWIG_TypeCheck(const char *c, swig_type_info *ty) {
449 if (ty) {
450 swig_cast_info *iter = ty->cast;
451 while (iter) {
452 if (strcmp(iter->type->name, c) == 0) {
453 if (iter == ty->cast)
454 return iter;
455 /* Move iter to the top of the linked list */
456 iter->prev->next = iter->next;
457 if (iter->next)
458 iter->next->prev = iter->prev;
459 iter->next = ty->cast;
460 iter->prev = 0;
461 if (ty->cast) ty->cast->prev = iter;
462 ty->cast = iter;
463 return iter;
464 }
465 iter = iter->next;
466 }
467 }
468 return 0;
469}
470
471/*
472 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
473*/
476 if (ty) {
477 swig_cast_info *iter = ty->cast;
478 while (iter) {
479 if (iter->type == from) {
480 if (iter == ty->cast)
481 return iter;
482 /* Move iter to the top of the linked list */
483 iter->prev->next = iter->next;
484 if (iter->next)
485 iter->next->prev = iter->prev;
486 iter->next = ty->cast;
487 iter->prev = 0;
488 if (ty->cast) ty->cast->prev = iter;
489 ty->cast = iter;
490 return iter;
491 }
492 iter = iter->next;
493 }
494 }
495 return 0;
496}
497
498/*
499 Cast a pointer up an inheritance hierarchy
500*/
502SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
503 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
504}
505
506/*
507 Dynamic pointer casting. Down an inheritance hierarchy
508*/
511 swig_type_info *lastty = ty;
512 if (!ty || !ty->dcast) return ty;
513 while (ty && (ty->dcast)) {
514 ty = (*ty->dcast)(ptr);
515 if (ty) lastty = ty;
516 }
517 return lastty;
518}
519
520/*
521 Return the name associated with this type
522*/
523SWIGRUNTIMEINLINE const char *
525 return ty->name;
526}
527
528/*
529 Return the pretty name associated with this type,
530 that is an unmangled type name in a form presentable to the user.
531*/
532SWIGRUNTIME const char *
534 /* The "str" field contains the equivalent pretty names of the
535 type, separated by vertical-bar characters. Choose the last
536 name. It should be the most specific; a fully resolved name
537 but not necessarily with default template parameters expanded. */
538 if (!type) return NULL;
539 if (type->str != NULL) {
540 const char *last_name = type->str;
541 const char *s;
542 for (s = type->str; *s; s++)
543 if (*s == '|') last_name = s+1;
544 return last_name;
545 }
546 else
547 return type->name;
548}
549
550/*
551 Set the clientdata field for a type
552*/
553SWIGRUNTIME void
555 swig_cast_info *cast = ti->cast;
556 /* if (ti->clientdata == clientdata) return; */
557 ti->clientdata = clientdata;
558
559 while (cast) {
560 if (!cast->converter) {
561 swig_type_info *tc = cast->type;
562 if (!tc->clientdata) {
564 }
565 }
566 cast = cast->next;
567 }
568}
569SWIGRUNTIME void
572 ti->owndata = 1;
573}
574
575/*
576 Search for a swig_type_info structure only by mangled name
577 Search is a O(log #types)
578
579 We start searching at module start, and finish searching when start == end.
580 Note: if start == end at the beginning of the function, we go all the way around
581 the circular list.
582*/
585 swig_module_info *end,
586 const char *name) {
587 swig_module_info *iter = start;
588 do {
589 if (iter->size) {
590 size_t l = 0;
591 size_t r = iter->size - 1;
592 do {
593 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
594 size_t i = (l + r) >> 1;
595 const char *iname = iter->types[i]->name;
596 if (iname) {
597 int compare = strcmp(name, iname);
598 if (compare == 0) {
599 return iter->types[i];
600 } else if (compare < 0) {
601 if (i) {
602 r = i - 1;
603 } else {
604 break;
605 }
606 } else if (compare > 0) {
607 l = i + 1;
608 }
609 } else {
610 break; /* should never happen */
611 }
612 } while (l <= r);
613 }
614 iter = iter->next;
615 } while (iter != end);
616 return 0;
617}
618
619/*
620 Search for a swig_type_info structure for either a mangled name or a human readable name.
621 It first searches the mangled names of the types, which is a O(log #types)
622 If a type is not found it then searches the human readable names, which is O(#types).
623
624 We start searching at module start, and finish searching when start == end.
625 Note: if start == end at the beginning of the function, we go all the way around
626 the circular list.
627*/
630 swig_module_info *end,
631 const char *name) {
632 /* STEP 1: Search the name field using binary search */
634 if (ret) {
635 return ret;
636 } else {
637 /* STEP 2: If the type hasn't been found, do a complete search
638 of the str field (the human readable name) */
639 swig_module_info *iter = start;
640 do {
641 size_t i = 0;
642 for (; i < iter->size; ++i) {
643 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
644 return iter->types[i];
645 }
646 iter = iter->next;
647 } while (iter != end);
648 }
649
650 /* neither found a match */
651 return 0;
652}
653
654/*
655 Pack binary data into a string
656*/
657SWIGRUNTIME char *
658SWIG_PackData(char *c, void *ptr, size_t sz) {
659 static const char hex[17] = "0123456789abcdef";
660 const unsigned char *u = (unsigned char *) ptr;
661 const unsigned char *eu = u + sz;
662 for (; u != eu; ++u) {
663 unsigned char uu = *u;
664 *(c++) = hex[(uu & 0xf0) >> 4];
665 *(c++) = hex[uu & 0xf];
666 }
667 return c;
668}
669
670/*
671 Unpack binary data from a string
672*/
673SWIGRUNTIME const char *
674SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
675 unsigned char *u = (unsigned char *) ptr;
676 const unsigned char *eu = u + sz;
677 for (; u != eu; ++u) {
678 char d = *(c++);
679 unsigned char uu;
680 if ((d >= '0') && (d <= '9'))
681 uu = (unsigned char)((d - '0') << 4);
682 else if ((d >= 'a') && (d <= 'f'))
683 uu = (unsigned char)((d - ('a'-10)) << 4);
684 else
685 return (char *) 0;
686 d = *(c++);
687 if ((d >= '0') && (d <= '9'))
688 uu |= (unsigned char)(d - '0');
689 else if ((d >= 'a') && (d <= 'f'))
690 uu |= (unsigned char)(d - ('a'-10));
691 else
692 return (char *) 0;
693 *u = uu;
694 }
695 return c;
696}
697
698/*
699 Pack 'void *' into a string buffer.
700*/
701SWIGRUNTIME char *
702SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
703 char *r = buff;
704 if ((2*sizeof(void *) + 2) > bsz) return 0;
705 *(r++) = '_';
706 r = SWIG_PackData(r,&ptr,sizeof(void *));
707 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
708 strcpy(r,name);
709 return buff;
710}
711
712SWIGRUNTIME const char *
713SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
714 if (*c != '_') {
715 if (strcmp(c,"NULL") == 0) {
716 *ptr = (void *) 0;
717 return name;
718 } else {
719 return 0;
720 }
721 }
722 return SWIG_UnpackData(++c,ptr,sizeof(void *));
723}
724
725SWIGRUNTIME char *
726SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
727 char *r = buff;
728 size_t lname = (name ? strlen(name) : 0);
729 if ((2*sz + 2 + lname) > bsz) return 0;
730 *(r++) = '_';
731 r = SWIG_PackData(r,ptr,sz);
732 if (lname) {
733 strncpy(r,name,lname+1);
734 } else {
735 *r = 0;
736 }
737 return buff;
738}
739
740SWIGRUNTIME const char *
741SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
742 if (*c != '_') {
743 if (strcmp(c,"NULL") == 0) {
744 memset(ptr,0,sz);
745 return name;
746 } else {
747 return 0;
748 }
749 }
750 return SWIG_UnpackData(++c,ptr,sz);
751}
752
753#ifdef __cplusplus
754}
755#endif
756
757/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
758#define SWIG_UnknownError -1
759#define SWIG_IOError -2
760#define SWIG_RuntimeError -3
761#define SWIG_IndexError -4
762#define SWIG_TypeError -5
763#define SWIG_DivisionByZero -6
764#define SWIG_OverflowError -7
765#define SWIG_SyntaxError -8
766#define SWIG_ValueError -9
767#define SWIG_SystemError -10
768#define SWIG_AttributeError -11
769#define SWIG_MemoryError -12
770#define SWIG_NullReferenceError -13
771
772
773/* Compatibility macros for Python 3 */
774#if PY_VERSION_HEX >= 0x03000000
775
776#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
777#define PyInt_Check(x) PyLong_Check(x)
778#define PyInt_AsLong(x) PyLong_AsLong(x)
779#define PyInt_FromLong(x) PyLong_FromLong(x)
780#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
781#define PyString_Check(name) PyBytes_Check(name)
782#define PyString_FromString(x) PyUnicode_FromString(x)
783#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
784#define PyString_AsString(str) PyBytes_AsString(str)
785#define PyString_Size(str) PyBytes_Size(str)
786#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
787#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
788#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
789
790#endif
791
792#ifndef Py_TYPE
793# define Py_TYPE(op) ((op)->ob_type)
794#endif
795
796/* SWIG APIs for compatibility of both Python 2 & 3 */
797
798#if PY_VERSION_HEX >= 0x03000000
799# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
800#else
801# define SWIG_Python_str_FromFormat PyString_FromFormat
802#endif
803
804
805SWIGINTERN char*
807{
808#if PY_VERSION_HEX >= 0x03030000
809 return (char *)PyUnicode_AsUTF8(str);
810#else
811 return PyString_AsString(str);
812#endif
813}
814
815/* Was useful for Python 3.0.x-3.2.x - now provided only for compatibility
816 * with any uses in user interface files. */
817#define SWIG_Python_str_DelForPy3(x)
818
819
820SWIGINTERN PyObject*
822{
823#if PY_VERSION_HEX >= 0x03000000
824 return PyUnicode_FromString(c);
825#else
826 return PyString_FromString(c);
827#endif
828}
829
830#ifndef PyObject_DEL
831# define PyObject_DEL PyObject_Del
832#endif
833
834/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
835# define SWIGPY_USE_CAPSULE
836#ifdef SWIGPYTHON_BUILTIN
837# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
838#else
839# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
840#endif
841# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
842
843#if PY_VERSION_HEX < 0x03020000
844#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
845#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
846#define Py_hash_t long
847#endif
848
849/* -----------------------------------------------------------------------------
850 * error manipulation
851 * ----------------------------------------------------------------------------- */
852
853SWIGRUNTIME PyObject*
855 PyObject* type = 0;
856 switch(code) {
857 case SWIG_MemoryError:
858 type = PyExc_MemoryError;
859 break;
860 case SWIG_IOError:
861 type = PyExc_IOError;
862 break;
864 type = PyExc_RuntimeError;
865 break;
866 case SWIG_IndexError:
867 type = PyExc_IndexError;
868 break;
869 case SWIG_TypeError:
870 type = PyExc_TypeError;
871 break;
873 type = PyExc_ZeroDivisionError;
874 break;
876 type = PyExc_OverflowError;
877 break;
878 case SWIG_SyntaxError:
879 type = PyExc_SyntaxError;
880 break;
881 case SWIG_ValueError:
882 type = PyExc_ValueError;
883 break;
884 case SWIG_SystemError:
885 type = PyExc_SystemError;
886 break;
888 type = PyExc_AttributeError;
889 break;
890 default:
891 type = PyExc_RuntimeError;
892 }
893 return type;
894}
895
896
897SWIGRUNTIME void
898SWIG_Python_AddErrorMsg(const char* mesg)
899{
900 PyObject *type = 0;
901 PyObject *value = 0;
902 PyObject *traceback = 0;
903
904 if (PyErr_Occurred())
905 PyErr_Fetch(&type, &value, &traceback);
906 if (value) {
907 PyObject *old_str = PyObject_Str(value);
908 const char *tmp = SWIG_Python_str_AsChar(old_str);
909 PyErr_Clear();
910 Py_XINCREF(type);
911 if (tmp)
912 PyErr_Format(type, "%s %s", tmp, mesg);
913 else
914 PyErr_Format(type, "%s", mesg);
915 Py_DECREF(old_str);
916 Py_DECREF(value);
917 } else {
918 PyErr_SetString(PyExc_RuntimeError, mesg);
919 }
920}
921
922SWIGRUNTIME int
924{
925 PyObject *error;
926 if (obj)
927 return 0;
928 error = PyErr_Occurred();
929 return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
930}
931
932SWIGRUNTIME void
934{
936 /* Use existing TypeError to preserve stacktrace and enhance with given message */
937 PyObject *newvalue;
938 PyObject *type = NULL, *value = NULL, *traceback = NULL;
939 PyErr_Fetch(&type, &value, &traceback);
940#if PY_VERSION_HEX >= 0x03000000
941 newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
942#else
943 newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
944#endif
945 if (newvalue) {
946 Py_XDECREF(value);
947 PyErr_Restore(type, newvalue, traceback);
948 } else {
949 PyErr_Restore(type, value, traceback);
950 }
951 } else {
952 /* Raise TypeError using given message */
953 PyErr_SetString(PyExc_TypeError, message);
954 }
955}
956
957#if defined(SWIG_PYTHON_NO_THREADS)
958# if defined(SWIG_PYTHON_THREADS)
959# undef SWIG_PYTHON_THREADS
960# endif
961#endif
962#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
963# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
964# define SWIG_PYTHON_USE_GIL
965# endif
966# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
967# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
968# if PY_VERSION_HEX < 0x03070000
969# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
970# else
971# define SWIG_PYTHON_INITIALIZE_THREADS
972# endif
973# endif
974# ifdef __cplusplus /* C++ code */
975 class SWIG_Python_Thread_Block {
976 bool status;
977 PyGILState_STATE state;
978 public:
979 void end() { if (status) { PyGILState_Release(state); status = false;} }
980 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
981 ~SWIG_Python_Thread_Block() { end(); }
982 };
983 class SWIG_Python_Thread_Allow {
984 bool status;
985 PyThreadState *save;
986 public:
987 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
988 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
989 ~SWIG_Python_Thread_Allow() { end(); }
990 };
991# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
992# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
993# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
994# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
995# else /* C code */
996# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
997# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
998# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
999# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1000# endif
1001# else /* Old thread way, not implemented, user must provide it */
1002# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1003# define SWIG_PYTHON_INITIALIZE_THREADS
1004# endif
1005# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1006# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1007# endif
1008# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1009# define SWIG_PYTHON_THREAD_END_BLOCK
1010# endif
1011# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1012# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1013# endif
1014# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1015# define SWIG_PYTHON_THREAD_END_ALLOW
1016# endif
1017# endif
1018#else /* No thread support */
1019# define SWIG_PYTHON_INITIALIZE_THREADS
1020# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1021# define SWIG_PYTHON_THREAD_END_BLOCK
1022# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1023# define SWIG_PYTHON_THREAD_END_ALLOW
1024#endif
1025
1026/* -----------------------------------------------------------------------------
1027 * Python API portion that goes into the runtime
1028 * ----------------------------------------------------------------------------- */
1029
1030#ifdef __cplusplus
1031extern "C" {
1032#endif
1033
1034/* -----------------------------------------------------------------------------
1035 * Constant declarations
1036 * ----------------------------------------------------------------------------- */
1037
1038/* Constant Types */
1039#define SWIG_PY_POINTER 4
1040#define SWIG_PY_BINARY 5
1041
1042/* Constant information structure */
1051
1052#ifdef __cplusplus
1053}
1054#endif
1055
1056
1057/* -----------------------------------------------------------------------------
1058 * pyrun.swg
1059 *
1060 * This file contains the runtime support for Python modules
1061 * and includes code for managing global variables and pointer
1062 * type checking.
1063 *
1064 * ----------------------------------------------------------------------------- */
1065
1066#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
1067# error "This version of SWIG only supports Python >= 2.7"
1068#endif
1069
1070#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
1071# error "This version of SWIG only supports Python 3 >= 3.3"
1072#endif
1073
1074/* Common SWIG API */
1075
1076/* for raw pointers */
1077#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1078#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1079#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1080
1081#ifdef SWIGPYTHON_BUILTIN
1082#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1083#else
1084#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1085#endif
1086
1087#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1088
1089#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1090#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1091#define swig_owntype int
1092
1093/* for raw packed data */
1094#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1095#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1096
1097/* for class or struct pointers */
1098#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1099#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1100
1101/* for C or C++ function pointers */
1102#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1103#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1104
1105/* for C++ member pointers, ie, member methods */
1106#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1107#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1108
1109
1110/* Runtime API */
1111
1112#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1113#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1114#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1115
1116#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1117#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1118#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1119#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1120#define SWIG_fail goto fail
1121
1122
1123/* Runtime API implementation */
1124
1125/* Error manipulation */
1126
1127SWIGINTERN void
1128SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1130 PyErr_SetObject(errtype, obj);
1131 Py_DECREF(obj);
1133}
1134
1135SWIGINTERN void
1136SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1138 PyErr_SetString(errtype, msg);
1140}
1141
1142#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1143
1144/* Set a constant value */
1145
1146#if defined(SWIGPYTHON_BUILTIN)
1147
1148SWIGINTERN void
1149SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1150 PyObject *s = PyString_InternFromString(key);
1151 PyList_Append(seq, s);
1152 Py_DECREF(s);
1153}
1154
1155SWIGINTERN void
1156SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1157 PyDict_SetItemString(d, name, obj);
1158 Py_DECREF(obj);
1159 if (public_interface)
1160 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1161}
1162
1163#else
1164
1165SWIGINTERN void
1166SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1167 PyDict_SetItemString(d, name, obj);
1168 Py_DECREF(obj);
1169}
1170
1171#endif
1172
1173/* Append a value to the result obj */
1174
1175SWIGINTERN PyObject*
1176SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1177 if (!result) {
1178 result = obj;
1179 } else if (result == Py_None) {
1180 Py_DECREF(result);
1181 result = obj;
1182 } else {
1183 if (!PyList_Check(result)) {
1184 PyObject *o2 = result;
1185 result = PyList_New(1);
1186 if (result) {
1187 PyList_SET_ITEM(result, 0, o2);
1188 } else {
1189 Py_DECREF(obj);
1190 return o2;
1191 }
1192 }
1193 PyList_Append(result,obj);
1194 Py_DECREF(obj);
1195 }
1196 return result;
1197}
1198
1199/* Unpack the argument tuple */
1200
1201SWIGINTERN Py_ssize_t
1202SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1203{
1204 if (!args) {
1205 if (!min && !max) {
1206 return 1;
1207 } else {
1208 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1209 name, (min == max ? "" : "at least "), (int)min);
1210 return 0;
1211 }
1212 }
1213 if (!PyTuple_Check(args)) {
1214 if (min <= 1 && max >= 1) {
1215 Py_ssize_t i;
1216 objs[0] = args;
1217 for (i = 1; i < max; ++i) {
1218 objs[i] = 0;
1219 }
1220 return 2;
1221 }
1222 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1223 return 0;
1224 } else {
1225 Py_ssize_t l = PyTuple_GET_SIZE(args);
1226 if (l < min) {
1227 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1228 name, (min == max ? "" : "at least "), (int)min, (int)l);
1229 return 0;
1230 } else if (l > max) {
1231 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1232 name, (min == max ? "" : "at most "), (int)max, (int)l);
1233 return 0;
1234 } else {
1235 Py_ssize_t i;
1236 for (i = 0; i < l; ++i) {
1237 objs[i] = PyTuple_GET_ITEM(args, i);
1238 }
1239 for (; l < max; ++l) {
1240 objs[l] = 0;
1241 }
1242 return i + 1;
1243 }
1244 }
1245}
1246
1247SWIGINTERN int
1248SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
1249 int no_kwargs = 1;
1250 if (kwargs) {
1251 assert(PyDict_Check(kwargs));
1252 if (PyDict_Size(kwargs) > 0) {
1253 PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
1254 no_kwargs = 0;
1255 }
1256 }
1257 return no_kwargs;
1258}
1259
1260/* A functor is a function object with one single object argument */
1261#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1262
1263/*
1264 Helper for static pointer initialization for both C and C++ code, for example
1265 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1266*/
1267#ifdef __cplusplus
1268#define SWIG_STATIC_POINTER(var) var
1269#else
1270#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1271#endif
1272
1273#ifdef __cplusplus
1274extern "C" {
1275#endif
1276
1277/* Python-specific SWIG API */
1278#define SWIG_newvarlink() SWIG_Python_newvarlink()
1279#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
1280#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
1281
1282/* -----------------------------------------------------------------------------
1283 * global variable support code.
1284 * ----------------------------------------------------------------------------- */
1285
1286typedef struct swig_globalvar {
1287 char *name; /* Name of global variable */
1288 PyObject *(*get_attr)(void); /* Return the current value */
1289 int (*set_attr)(PyObject *); /* Set the value */
1292
1297
1298SWIGINTERN PyObject *
1300#if PY_VERSION_HEX >= 0x03000000
1301 return PyUnicode_InternFromString("<Swig global variables>");
1302#else
1303 return PyString_FromString("<Swig global variables>");
1304#endif
1305}
1306
1307SWIGINTERN PyObject *
1308swig_varlink_str(PyObject *o) {
1310#if PY_VERSION_HEX >= 0x03000000
1311 PyObject *str = PyUnicode_InternFromString("(");
1312 PyObject *tail;
1313 PyObject *joined;
1314 swig_globalvar *var;
1315 for (var = v->vars; var; var=var->next) {
1316 tail = PyUnicode_FromString(var->name);
1317 joined = PyUnicode_Concat(str, tail);
1318 Py_DecRef(str);
1319 Py_DecRef(tail);
1320 str = joined;
1321 if (var->next) {
1322 tail = PyUnicode_InternFromString(", ");
1323 joined = PyUnicode_Concat(str, tail);
1324 Py_DecRef(str);
1325 Py_DecRef(tail);
1326 str = joined;
1327 }
1328 }
1329 tail = PyUnicode_InternFromString(")");
1330 joined = PyUnicode_Concat(str, tail);
1331 Py_DecRef(str);
1332 Py_DecRef(tail);
1333 str = joined;
1334#else
1335 PyObject *str = PyString_FromString("(");
1336 swig_globalvar *var;
1337 for (var = v->vars; var; var=var->next) {
1338 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
1339 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
1340 }
1341 PyString_ConcatAndDel(&str,PyString_FromString(")"));
1342#endif
1343 return str;
1344}
1345
1346SWIGINTERN void
1349 swig_globalvar *var = v->vars;
1350 while (var) {
1351 swig_globalvar *n = var->next;
1352 free(var->name);
1353 free(var);
1354 var = n;
1355 }
1356}
1357
1358SWIGINTERN PyObject *
1359swig_varlink_getattr(PyObject *o, char *n) {
1361 PyObject *res = NULL;
1362 swig_globalvar *var = v->vars;
1363 while (var) {
1364 if (strcmp(var->name,n) == 0) {
1365 res = (*var->get_attr)();
1366 break;
1367 }
1368 var = var->next;
1369 }
1370 if (res == NULL && !PyErr_Occurred()) {
1371 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
1372 }
1373 return res;
1374}
1375
1376SWIGINTERN int
1377swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
1379 int res = 1;
1380 swig_globalvar *var = v->vars;
1381 while (var) {
1382 if (strcmp(var->name,n) == 0) {
1383 res = (*var->set_attr)(p);
1384 break;
1385 }
1386 var = var->next;
1387 }
1388 if (res == 1 && !PyErr_Occurred()) {
1389 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
1390 }
1391 return res;
1392}
1393
1394SWIGINTERN PyTypeObject*
1396 static char varlink__doc__[] = "Swig var link object";
1397 static PyTypeObject varlink_type;
1398 static int type_init = 0;
1399 if (!type_init) {
1400 const PyTypeObject tmp = {
1401#if PY_VERSION_HEX >= 0x03000000
1402 PyVarObject_HEAD_INIT(NULL, 0)
1403#else
1404 PyObject_HEAD_INIT(NULL)
1405 0, /* ob_size */
1406#endif
1407 "swigvarlink", /* tp_name */
1408 sizeof(swig_varlinkobject), /* tp_basicsize */
1409 0, /* tp_itemsize */
1410 (destructor) swig_varlink_dealloc, /* tp_dealloc */
1411#if PY_VERSION_HEX < 0x030800b4
1412 (printfunc)0, /*tp_print*/
1413#else
1414 (Py_ssize_t)0, /*tp_vectorcall_offset*/
1415#endif
1416 (getattrfunc) swig_varlink_getattr, /* tp_getattr */
1417 (setattrfunc) swig_varlink_setattr, /* tp_setattr */
1418 0, /* tp_compare */
1419 (reprfunc) swig_varlink_repr, /* tp_repr */
1420 0, /* tp_as_number */
1421 0, /* tp_as_sequence */
1422 0, /* tp_as_mapping */
1423 0, /* tp_hash */
1424 0, /* tp_call */
1425 (reprfunc) swig_varlink_str, /* tp_str */
1426 0, /* tp_getattro */
1427 0, /* tp_setattro */
1428 0, /* tp_as_buffer */
1429 0, /* tp_flags */
1430 varlink__doc__, /* tp_doc */
1431 0, /* tp_traverse */
1432 0, /* tp_clear */
1433 0, /* tp_richcompare */
1434 0, /* tp_weaklistoffset */
1435 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
1436 0, /* tp_del */
1437 0, /* tp_version_tag */
1438#if PY_VERSION_HEX >= 0x03040000
1439 0, /* tp_finalize */
1440#endif
1441#if PY_VERSION_HEX >= 0x03080000
1442 0, /* tp_vectorcall */
1443#endif
1444#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
1445 0, /* tp_print */
1446#endif
1447#ifdef COUNT_ALLOCS
1448 0, /* tp_allocs */
1449 0, /* tp_frees */
1450 0, /* tp_maxalloc */
1451 0, /* tp_prev */
1452 0 /* tp_next */
1453#endif
1454 };
1455 varlink_type = tmp;
1456 type_init = 1;
1457 if (PyType_Ready(&varlink_type) < 0)
1458 return NULL;
1459 }
1460 return &varlink_type;
1461}
1462
1463/* Create a variable linking object for use later */
1464SWIGINTERN PyObject *
1466 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
1467 if (result) {
1468 result->vars = 0;
1469 }
1470 return ((PyObject*) result);
1471}
1472
1473SWIGINTERN void
1474SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
1476 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
1477 if (gv) {
1478 size_t size = strlen(name)+1;
1479 gv->name = (char *)malloc(size);
1480 if (gv->name) {
1481 memcpy(gv->name, name, size);
1482 gv->get_attr = get_attr;
1483 gv->set_attr = set_attr;
1484 gv->next = v->vars;
1485 }
1486 }
1487 v->vars = gv;
1488}
1489
1490
1491static PyObject *Swig_Globals_global = NULL;
1492
1493SWIGINTERN PyObject *
1495 if (Swig_Globals_global == NULL) {
1497 }
1498 return Swig_Globals_global;
1499}
1500
1501#ifdef __cplusplus
1502}
1503#endif
1504
1505/* -----------------------------------------------------------------------------
1506 * Pointer declarations
1507 * ----------------------------------------------------------------------------- */
1508
1509/* Flags for new pointer objects */
1510#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1511#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1512
1513#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1514
1515#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1516#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1517
1518#ifdef __cplusplus
1519extern "C" {
1520#endif
1521
1522/* The python void return value */
1523
1524SWIGRUNTIMEINLINE PyObject *
1526{
1527 PyObject *none = Py_None;
1528 Py_INCREF(none);
1529 return none;
1530}
1531
1532/* SwigPyClientData */
1533
1534typedef struct {
1535 PyObject *klass;
1536 PyObject *newraw;
1537 PyObject *newargs;
1538 PyObject *destroy;
1541 PyTypeObject *pytype;
1543
1546{
1548 int fail = data ? data->implicitconv : 0;
1549 if (fail)
1550 PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
1551 return fail;
1552}
1553
1554SWIGRUNTIMEINLINE PyObject *
1556 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1557 PyObject *klass = data ? data->klass : 0;
1558 return (klass ? klass : PyExc_RuntimeError);
1559}
1560
1561
1564{
1565 if (!obj) {
1566 return 0;
1567 } else {
1568 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1569 /* the klass element */
1570 data->klass = obj;
1571 Py_INCREF(data->klass);
1572 /* the newraw method and newargs arguments used to create a new raw instance */
1573 if (PyClass_Check(obj)) {
1574 data->newraw = 0;
1575 Py_INCREF(obj);
1576 data->newargs = obj;
1577 } else {
1578 data->newraw = PyObject_GetAttrString(data->klass, "__new__");
1579 if (data->newraw) {
1580 data->newargs = PyTuple_New(1);
1581 if (data->newargs) {
1582 Py_INCREF(obj);
1583 PyTuple_SET_ITEM(data->newargs, 0, obj);
1584 } else {
1585 Py_DECREF(data->newraw);
1586 Py_DECREF(data->klass);
1587 free(data);
1588 return 0;
1589 }
1590 } else {
1591 Py_INCREF(obj);
1592 data->newargs = obj;
1593 }
1594 }
1595 /* the destroy method, aka as the C++ delete method */
1596 data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1597 if (PyErr_Occurred()) {
1598 PyErr_Clear();
1599 data->destroy = 0;
1600 }
1601 if (data->destroy) {
1602 data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
1603 } else {
1604 data->delargs = 0;
1605 }
1606 data->implicitconv = 0;
1607 data->pytype = 0;
1608 return data;
1609 }
1610}
1611
1612SWIGRUNTIME void
1614{
1615 Py_XDECREF(data->klass);
1616 Py_XDECREF(data->newraw);
1617 Py_XDECREF(data->newargs);
1618 Py_XDECREF(data->destroy);
1619 free(data);
1620}
1621
1622/* =============== SwigPyObject =====================*/
1623
1624typedef struct {
1625 PyObject_HEAD
1626 void *ptr;
1628 int own;
1629 PyObject *next;
1630#ifdef SWIGPYTHON_BUILTIN
1631 PyObject *dict;
1632#endif
1633} SwigPyObject;
1634
1635
1636#ifdef SWIGPYTHON_BUILTIN
1637
1638SWIGRUNTIME PyObject *
1639SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1640{
1641 SwigPyObject *sobj = (SwigPyObject *)v;
1642
1643 if (!sobj->dict)
1644 sobj->dict = PyDict_New();
1645
1646 Py_XINCREF(sobj->dict);
1647 return sobj->dict;
1648}
1649
1650#endif
1651
1652SWIGRUNTIME PyObject *
1654{
1655 return PyLong_FromVoidPtr(v->ptr);
1656}
1657
1658SWIGRUNTIME PyObject *
1660{
1661 PyObject *res = NULL;
1662 PyObject *args = PyTuple_New(1);
1663 if (args) {
1664 PyObject *val = SwigPyObject_long(v);
1665 if (val) {
1666 PyObject *ofmt;
1667 PyTuple_SET_ITEM(args, 0, val);
1668 ofmt = SWIG_Python_str_FromChar(fmt);
1669 if (ofmt) {
1670#if PY_VERSION_HEX >= 0x03000000
1671 res = PyUnicode_Format(ofmt,args);
1672#else
1673 res = PyString_Format(ofmt,args);
1674#endif
1675 Py_DECREF(ofmt);
1676 }
1677 }
1678 Py_DECREF(args);
1679 }
1680 return res;
1681}
1682
1683SWIGRUNTIME PyObject *
1685{
1686 return SwigPyObject_format("%o",v);
1687}
1688
1689SWIGRUNTIME PyObject *
1691{
1692 return SwigPyObject_format("%x",v);
1693}
1694
1695SWIGRUNTIME PyObject *
1697{
1698 const char *name = SWIG_TypePrettyName(v->ty);
1699 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1700 if (repr && v->next) {
1701 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1702 if (nrep) {
1703# if PY_VERSION_HEX >= 0x03000000
1704 PyObject *joined = PyUnicode_Concat(repr, nrep);
1705 Py_DecRef(repr);
1706 Py_DecRef(nrep);
1707 repr = joined;
1708# else
1709 PyString_ConcatAndDel(&repr,nrep);
1710# endif
1711 } else {
1712 Py_DecRef(repr);
1713 repr = NULL;
1714 }
1715 }
1716 return repr;
1717}
1718
1719/* We need a version taking two PyObject* parameters so it's a valid
1720 * PyCFunction to use in swigobject_methods[]. */
1721SWIGRUNTIME PyObject *
1722SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1723{
1724 return SwigPyObject_repr((SwigPyObject*)v);
1725}
1726
1727SWIGRUNTIME int
1729{
1730 void *i = v->ptr;
1731 void *j = w->ptr;
1732 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1733}
1734
1735/* Added for Python 3.x, would it also be useful for Python 2.x? */
1736SWIGRUNTIME PyObject*
1738{
1739 PyObject* res;
1740 if( op != Py_EQ && op != Py_NE ) {
1741 Py_INCREF(Py_NotImplemented);
1742 return Py_NotImplemented;
1743 }
1744 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1745 return res;
1746}
1747
1748
1749SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1750
1751#ifdef SWIGPYTHON_BUILTIN
1752static swig_type_info *SwigPyObject_stype = 0;
1753SWIGRUNTIME PyTypeObject*
1754SwigPyObject_type(void) {
1755 SwigPyClientData *cd;
1756 assert(SwigPyObject_stype);
1757 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1758 assert(cd);
1759 assert(cd->pytype);
1760 return cd->pytype;
1761}
1762#else
1763SWIGRUNTIME PyTypeObject*
1765 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1766 return type;
1767}
1768#endif
1769
1771SwigPyObject_Check(PyObject *op) {
1772#ifdef SWIGPYTHON_BUILTIN
1773 PyTypeObject *target_tp = SwigPyObject_type();
1774 if (PyType_IsSubtype(op->ob_type, target_tp))
1775 return 1;
1776 return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1777#else
1778 return (Py_TYPE(op) == SwigPyObject_type())
1779 || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1780#endif
1781}
1782
1783SWIGRUNTIME PyObject *
1784SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1785
1786static PyObject* Swig_Capsule_global = NULL;
1787
1788SWIGRUNTIME void
1790{
1791 SwigPyObject *sobj = (SwigPyObject *) v;
1792 PyObject *next = sobj->next;
1793 if (sobj->own == SWIG_POINTER_OWN) {
1794 swig_type_info *ty = sobj->ty;
1795 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1796 PyObject *destroy = data ? data->destroy : 0;
1797 if (destroy) {
1798 /* destroy is always a VARARGS method */
1799 PyObject *res;
1800
1801 /* PyObject_CallFunction() has the potential to silently drop
1802 the active exception. In cases of unnamed temporary
1803 variable or where we just finished iterating over a generator
1804 StopIteration will be active right now, and this needs to
1805 remain true upon return from SwigPyObject_dealloc. So save
1806 and restore. */
1807
1808 PyObject *type = NULL, *value = NULL, *traceback = NULL;
1809 PyErr_Fetch(&type, &value, &traceback);
1810
1811 if (data->delargs) {
1812 /* we need to create a temporary object to carry the destroy operation */
1813 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1814 if (tmp) {
1815 res = SWIG_Python_CallFunctor(destroy, tmp);
1816 } else {
1817 res = 0;
1818 }
1819 Py_XDECREF(tmp);
1820 } else {
1821 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1822 PyObject *mself = PyCFunction_GET_SELF(destroy);
1823 res = ((*meth)(mself, v));
1824 }
1825 if (!res)
1826 PyErr_WriteUnraisable(destroy);
1827
1828 PyErr_Restore(type, value, traceback);
1829
1830 Py_XDECREF(res);
1831 }
1832#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1833 else {
1834 const char *name = SWIG_TypePrettyName(ty);
1835 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1836 }
1837#endif
1838 Py_XDECREF(Swig_Capsule_global);
1839 }
1840 Py_XDECREF(next);
1841#ifdef SWIGPYTHON_BUILTIN
1842 Py_XDECREF(sobj->dict);
1843#endif
1844 PyObject_DEL(v);
1845}
1846
1847SWIGRUNTIME PyObject*
1848SwigPyObject_append(PyObject* v, PyObject* next)
1849{
1850 SwigPyObject *sobj = (SwigPyObject *) v;
1851 if (!SwigPyObject_Check(next)) {
1852 PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1853 return NULL;
1854 }
1855 ((SwigPyObject *)next)->next = sobj->next;
1856 sobj->next = next;
1857 Py_INCREF(next);
1858 return SWIG_Py_Void();
1859}
1860
1861SWIGRUNTIME PyObject*
1862SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1863{
1864 SwigPyObject *sobj = (SwigPyObject *) v;
1865 if (sobj->next) {
1866 Py_INCREF(sobj->next);
1867 return sobj->next;
1868 } else {
1869 return SWIG_Py_Void();
1870 }
1871}
1872
1873SWIGINTERN PyObject*
1874SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1875{
1876 SwigPyObject *sobj = (SwigPyObject *)v;
1877 sobj->own = 0;
1878 return SWIG_Py_Void();
1879}
1880
1881SWIGINTERN PyObject*
1882SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1883{
1884 SwigPyObject *sobj = (SwigPyObject *)v;
1885 sobj->own = SWIG_POINTER_OWN;
1886 return SWIG_Py_Void();
1887}
1888
1889SWIGINTERN PyObject*
1890SwigPyObject_own(PyObject *v, PyObject *args)
1891{
1892 PyObject *val = 0;
1893 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
1894 return NULL;
1895 } else {
1896 SwigPyObject *sobj = (SwigPyObject *)v;
1897 PyObject *obj = PyBool_FromLong(sobj->own);
1898 if (val) {
1899 if (PyObject_IsTrue(val)) {
1900 Py_DECREF(SwigPyObject_acquire(v,args));
1901 } else {
1902 Py_DECREF(SwigPyObject_disown(v,args));
1903 }
1904 }
1905 return obj;
1906 }
1907}
1908
1909static PyMethodDef
1911 {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
1912 {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
1913 {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
1914 {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
1915 {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
1916 {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
1917 {0, 0, 0, 0}
1918};
1919
1920SWIGRUNTIME PyTypeObject*
1922 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1923
1924 static PyNumberMethods SwigPyObject_as_number = {
1925 (binaryfunc)0, /*nb_add*/
1926 (binaryfunc)0, /*nb_subtract*/
1927 (binaryfunc)0, /*nb_multiply*/
1928 /* nb_divide removed in Python 3 */
1929#if PY_VERSION_HEX < 0x03000000
1930 (binaryfunc)0, /*nb_divide*/
1931#endif
1932 (binaryfunc)0, /*nb_remainder*/
1933 (binaryfunc)0, /*nb_divmod*/
1934 (ternaryfunc)0,/*nb_power*/
1935 (unaryfunc)0, /*nb_negative*/
1936 (unaryfunc)0, /*nb_positive*/
1937 (unaryfunc)0, /*nb_absolute*/
1938 (inquiry)0, /*nb_nonzero*/
1939 0, /*nb_invert*/
1940 0, /*nb_lshift*/
1941 0, /*nb_rshift*/
1942 0, /*nb_and*/
1943 0, /*nb_xor*/
1944 0, /*nb_or*/
1945#if PY_VERSION_HEX < 0x03000000
1946 0, /*nb_coerce*/
1947#endif
1948 (unaryfunc)SwigPyObject_long, /*nb_int*/
1949#if PY_VERSION_HEX < 0x03000000
1950 (unaryfunc)SwigPyObject_long, /*nb_long*/
1951#else
1952 0, /*nb_reserved*/
1953#endif
1954 (unaryfunc)0, /*nb_float*/
1955#if PY_VERSION_HEX < 0x03000000
1956 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1957 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1958#endif
1959#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1960 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1961#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1962 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1963#else
1964 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1965#endif
1966 };
1967
1968 static PyTypeObject swigpyobject_type;
1969 static int type_init = 0;
1970 if (!type_init) {
1971 const PyTypeObject tmp = {
1972#if PY_VERSION_HEX >= 0x03000000
1973 PyVarObject_HEAD_INIT(NULL, 0)
1974#else
1975 PyObject_HEAD_INIT(NULL)
1976 0, /* ob_size */
1977#endif
1978 "SwigPyObject", /* tp_name */
1979 sizeof(SwigPyObject), /* tp_basicsize */
1980 0, /* tp_itemsize */
1981 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1982#if PY_VERSION_HEX < 0x030800b4
1983 (printfunc)0, /*tp_print*/
1984#else
1985 (Py_ssize_t)0, /*tp_vectorcall_offset*/
1986#endif
1987 (getattrfunc)0, /* tp_getattr */
1988 (setattrfunc)0, /* tp_setattr */
1989#if PY_VERSION_HEX >= 0x03000000
1990 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1991#else
1992 (cmpfunc)SwigPyObject_compare, /* tp_compare */
1993#endif
1994 (reprfunc)SwigPyObject_repr, /* tp_repr */
1995 &SwigPyObject_as_number, /* tp_as_number */
1996 0, /* tp_as_sequence */
1997 0, /* tp_as_mapping */
1998 (hashfunc)0, /* tp_hash */
1999 (ternaryfunc)0, /* tp_call */
2000 0, /* tp_str */
2001 PyObject_GenericGetAttr, /* tp_getattro */
2002 0, /* tp_setattro */
2003 0, /* tp_as_buffer */
2004 Py_TPFLAGS_DEFAULT, /* tp_flags */
2005 swigobject_doc, /* tp_doc */
2006 0, /* tp_traverse */
2007 0, /* tp_clear */
2008 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
2009 0, /* tp_weaklistoffset */
2010 0, /* tp_iter */
2011 0, /* tp_iternext */
2012 swigobject_methods, /* tp_methods */
2013 0, /* tp_members */
2014 0, /* tp_getset */
2015 0, /* tp_base */
2016 0, /* tp_dict */
2017 0, /* tp_descr_get */
2018 0, /* tp_descr_set */
2019 0, /* tp_dictoffset */
2020 0, /* tp_init */
2021 0, /* tp_alloc */
2022 0, /* tp_new */
2023 0, /* tp_free */
2024 0, /* tp_is_gc */
2025 0, /* tp_bases */
2026 0, /* tp_mro */
2027 0, /* tp_cache */
2028 0, /* tp_subclasses */
2029 0, /* tp_weaklist */
2030 0, /* tp_del */
2031 0, /* tp_version_tag */
2032#if PY_VERSION_HEX >= 0x03040000
2033 0, /* tp_finalize */
2034#endif
2035#if PY_VERSION_HEX >= 0x03080000
2036 0, /* tp_vectorcall */
2037#endif
2038#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2039 0, /* tp_print */
2040#endif
2041#ifdef COUNT_ALLOCS
2042 0, /* tp_allocs */
2043 0, /* tp_frees */
2044 0, /* tp_maxalloc */
2045 0, /* tp_prev */
2046 0 /* tp_next */
2047#endif
2048 };
2049 swigpyobject_type = tmp;
2050 type_init = 1;
2051 if (PyType_Ready(&swigpyobject_type) != 0)
2052 return NULL;
2053 }
2054 return &swigpyobject_type;
2055}
2056
2057SWIGRUNTIME PyObject *
2058SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2059{
2060 SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2061 if (sobj) {
2062 sobj->ptr = ptr;
2063 sobj->ty = ty;
2064 sobj->own = own;
2065 sobj->next = 0;
2066#ifdef SWIGPYTHON_BUILTIN
2067 sobj->dict = 0;
2068#endif
2069 if (own == SWIG_POINTER_OWN) {
2070 /* Obtain a reference to the Python capsule wrapping the module information, so that the
2071 * module information is correctly destroyed after all SWIG python objects have been freed
2072 * by the GC (and corresponding destructors invoked) */
2073 Py_XINCREF(Swig_Capsule_global);
2074 }
2075 }
2076 return (PyObject *)sobj;
2077}
2078
2079/* -----------------------------------------------------------------------------
2080 * Implements a simple Swig Packed type, and use it instead of string
2081 * ----------------------------------------------------------------------------- */
2082
2083typedef struct {
2084 PyObject_HEAD
2085 void *pack;
2087 size_t size;
2088} SwigPyPacked;
2089
2090SWIGRUNTIME PyObject *
2092{
2093 char result[SWIG_BUFFER_SIZE];
2094 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2095 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2096 } else {
2097 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2098 }
2099}
2100
2101SWIGRUNTIME PyObject *
2103{
2104 char result[SWIG_BUFFER_SIZE];
2105 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2106 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2107 } else {
2108 return SWIG_Python_str_FromChar(v->ty->name);
2109 }
2110}
2111
2112SWIGRUNTIME int
2114{
2115 size_t i = v->size;
2116 size_t j = w->size;
2117 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2118 return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
2119}
2120
2121SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2122
2123SWIGRUNTIME PyTypeObject*
2125 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2126 return type;
2127}
2128
2130SwigPyPacked_Check(PyObject *op) {
2131 return ((op)->ob_type == SwigPyPacked_TypeOnce())
2132 || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2133}
2134
2135SWIGRUNTIME void
2137{
2138 if (SwigPyPacked_Check(v)) {
2139 SwigPyPacked *sobj = (SwigPyPacked *) v;
2140 free(sobj->pack);
2141 }
2142 PyObject_DEL(v);
2143}
2144
2145SWIGRUNTIME PyTypeObject*
2147 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2148 static PyTypeObject swigpypacked_type;
2149 static int type_init = 0;
2150 if (!type_init) {
2151 const PyTypeObject tmp = {
2152#if PY_VERSION_HEX>=0x03000000
2153 PyVarObject_HEAD_INIT(NULL, 0)
2154#else
2155 PyObject_HEAD_INIT(NULL)
2156 0, /* ob_size */
2157#endif
2158 "SwigPyPacked", /* tp_name */
2159 sizeof(SwigPyPacked), /* tp_basicsize */
2160 0, /* tp_itemsize */
2161 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2162#if PY_VERSION_HEX < 0x030800b4
2163 (printfunc)0, /*tp_print*/
2164#else
2165 (Py_ssize_t)0, /*tp_vectorcall_offset*/
2166#endif
2167 (getattrfunc)0, /* tp_getattr */
2168 (setattrfunc)0, /* tp_setattr */
2169#if PY_VERSION_HEX>=0x03000000
2170 0, /* tp_reserved in 3.0.1 */
2171#else
2172 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2173#endif
2174 (reprfunc)SwigPyPacked_repr, /* tp_repr */
2175 0, /* tp_as_number */
2176 0, /* tp_as_sequence */
2177 0, /* tp_as_mapping */
2178 (hashfunc)0, /* tp_hash */
2179 (ternaryfunc)0, /* tp_call */
2180 (reprfunc)SwigPyPacked_str, /* tp_str */
2181 PyObject_GenericGetAttr, /* tp_getattro */
2182 0, /* tp_setattro */
2183 0, /* tp_as_buffer */
2184 Py_TPFLAGS_DEFAULT, /* tp_flags */
2185 swigpacked_doc, /* tp_doc */
2186 0, /* tp_traverse */
2187 0, /* tp_clear */
2188 0, /* tp_richcompare */
2189 0, /* tp_weaklistoffset */
2190 0, /* tp_iter */
2191 0, /* tp_iternext */
2192 0, /* tp_methods */
2193 0, /* tp_members */
2194 0, /* tp_getset */
2195 0, /* tp_base */
2196 0, /* tp_dict */
2197 0, /* tp_descr_get */
2198 0, /* tp_descr_set */
2199 0, /* tp_dictoffset */
2200 0, /* tp_init */
2201 0, /* tp_alloc */
2202 0, /* tp_new */
2203 0, /* tp_free */
2204 0, /* tp_is_gc */
2205 0, /* tp_bases */
2206 0, /* tp_mro */
2207 0, /* tp_cache */
2208 0, /* tp_subclasses */
2209 0, /* tp_weaklist */
2210 0, /* tp_del */
2211 0, /* tp_version_tag */
2212#if PY_VERSION_HEX >= 0x03040000
2213 0, /* tp_finalize */
2214#endif
2215#if PY_VERSION_HEX >= 0x03080000
2216 0, /* tp_vectorcall */
2217#endif
2218#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2219 0, /* tp_print */
2220#endif
2221#ifdef COUNT_ALLOCS
2222 0, /* tp_allocs */
2223 0, /* tp_frees */
2224 0, /* tp_maxalloc */
2225 0, /* tp_prev */
2226 0 /* tp_next */
2227#endif
2228 };
2229 swigpypacked_type = tmp;
2230 type_init = 1;
2231 if (PyType_Ready(&swigpypacked_type) != 0)
2232 return NULL;
2233 }
2234 return &swigpypacked_type;
2235}
2236
2237SWIGRUNTIME PyObject *
2238SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2239{
2240 SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2241 if (sobj) {
2242 void *pack = malloc(size);
2243 if (pack) {
2244 memcpy(pack, ptr, size);
2245 sobj->pack = pack;
2246 sobj->ty = ty;
2247 sobj->size = size;
2248 } else {
2249 PyObject_DEL((PyObject *) sobj);
2250 sobj = 0;
2251 }
2252 }
2253 return (PyObject *) sobj;
2254}
2255
2257SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2258{
2259 if (SwigPyPacked_Check(obj)) {
2260 SwigPyPacked *sobj = (SwigPyPacked *)obj;
2261 if (sobj->size != size) return 0;
2262 memcpy(ptr, sobj->pack, size);
2263 return sobj->ty;
2264 } else {
2265 return 0;
2266 }
2267}
2268
2269/* -----------------------------------------------------------------------------
2270 * pointers/data manipulation
2271 * ----------------------------------------------------------------------------- */
2272
2273static PyObject *Swig_This_global = NULL;
2274
2275SWIGRUNTIME PyObject *
2277{
2278 if (Swig_This_global == NULL)
2280 return Swig_This_global;
2281}
2282
2283/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2284
2285/* TODO: I don't know how to implement the fast getset in Python 3 right now */
2286#if PY_VERSION_HEX>=0x03000000
2287#define SWIG_PYTHON_SLOW_GETSET_THIS
2288#endif
2289
2292{
2293 PyObject *obj;
2294
2295 if (SwigPyObject_Check(pyobj))
2296 return (SwigPyObject *) pyobj;
2297
2298#ifdef SWIGPYTHON_BUILTIN
2299 (void)obj;
2300# ifdef PyWeakref_CheckProxy
2301 if (PyWeakref_CheckProxy(pyobj)) {
2302 pyobj = PyWeakref_GET_OBJECT(pyobj);
2303 if (pyobj && SwigPyObject_Check(pyobj))
2304 return (SwigPyObject*) pyobj;
2305 }
2306# endif
2307 return NULL;
2308#else
2309
2310 obj = 0;
2311
2312#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2313 if (PyInstance_Check(pyobj)) {
2314 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2315 } else {
2316 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2317 if (dictptr != NULL) {
2318 PyObject *dict = *dictptr;
2319 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2320 } else {
2321#ifdef PyWeakref_CheckProxy
2322 if (PyWeakref_CheckProxy(pyobj)) {
2323 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2324 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2325 }
2326#endif
2327 obj = PyObject_GetAttr(pyobj,SWIG_This());
2328 if (obj) {
2329 Py_DECREF(obj);
2330 } else {
2331 if (PyErr_Occurred()) PyErr_Clear();
2332 return 0;
2333 }
2334 }
2335 }
2336#else
2337 obj = PyObject_GetAttr(pyobj,SWIG_This());
2338 if (obj) {
2339 Py_DECREF(obj);
2340 } else {
2341 if (PyErr_Occurred()) PyErr_Clear();
2342 return 0;
2343 }
2344#endif
2345 if (obj && !SwigPyObject_Check(obj)) {
2346 /* a PyObject is called 'this', try to get the 'real this'
2347 SwigPyObject from it */
2348 return SWIG_Python_GetSwigThis(obj);
2349 }
2350 return (SwigPyObject *)obj;
2351#endif
2352}
2353
2354/* Acquire a pointer value */
2355
2356SWIGRUNTIME int
2357SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2358 if (own == SWIG_POINTER_OWN) {
2360 if (sobj) {
2361 int oldown = sobj->own;
2362 sobj->own = own;
2363 return oldown;
2364 }
2365 }
2366 return 0;
2367}
2368
2369/* Convert a pointer value */
2370
2371SWIGRUNTIME int
2372SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2373 int res;
2374 SwigPyObject *sobj;
2375 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2376
2377 if (!obj)
2378 return SWIG_ERROR;
2379 if (obj == Py_None && !implicit_conv) {
2380 if (ptr)
2381 *ptr = 0;
2383 }
2384
2385 res = SWIG_ERROR;
2386
2387 sobj = SWIG_Python_GetSwigThis(obj);
2388 if (own)
2389 *own = 0;
2390 while (sobj) {
2391 void *vptr = sobj->ptr;
2392 if (ty) {
2393 swig_type_info *to = sobj->ty;
2394 if (to == ty) {
2395 /* no type cast needed */
2396 if (ptr) *ptr = vptr;
2397 break;
2398 } else {
2399 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2400 if (!tc) {
2401 sobj = (SwigPyObject *)sobj->next;
2402 } else {
2403 if (ptr) {
2404 int newmemory = 0;
2405 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2406 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2407 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2408 if (own)
2409 *own = *own | SWIG_CAST_NEW_MEMORY;
2410 }
2411 }
2412 break;
2413 }
2414 }
2415 } else {
2416 if (ptr) *ptr = vptr;
2417 break;
2418 }
2419 }
2420 if (sobj) {
2421 if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
2423 } else {
2424 if (own)
2425 *own = *own | sobj->own;
2426 if (flags & SWIG_POINTER_DISOWN) {
2427 sobj->own = 0;
2428 }
2429 if (flags & SWIG_POINTER_CLEAR) {
2430 sobj->ptr = 0;
2431 }
2432 res = SWIG_OK;
2433 }
2434 } else {
2435 if (implicit_conv) {
2436 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2437 if (data && !data->implicitconv) {
2438 PyObject *klass = data->klass;
2439 if (klass) {
2440 PyObject *impconv;
2441 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2442 impconv = SWIG_Python_CallFunctor(klass, obj);
2443 data->implicitconv = 0;
2444 if (PyErr_Occurred()) {
2445 PyErr_Clear();
2446 impconv = 0;
2447 }
2448 if (impconv) {
2449 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2450 if (iobj) {
2451 void *vptr;
2452 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2453 if (SWIG_IsOK(res)) {
2454 if (ptr) {
2455 *ptr = vptr;
2456 /* transfer the ownership to 'ptr' */
2457 iobj->own = 0;
2458 res = SWIG_AddCast(res);
2459 res = SWIG_AddNewMask(res);
2460 } else {
2461 res = SWIG_AddCast(res);
2462 }
2463 }
2464 }
2465 Py_DECREF(impconv);
2466 }
2467 }
2468 }
2469 if (!SWIG_IsOK(res) && obj == Py_None) {
2470 if (ptr)
2471 *ptr = 0;
2472 if (PyErr_Occurred())
2473 PyErr_Clear();
2474 res = SWIG_OK;
2475 }
2476 }
2477 }
2478 return res;
2479}
2480
2481/* Convert a function ptr value */
2482
2483SWIGRUNTIME int
2484SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2485 if (!PyCFunction_Check(obj)) {
2486 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2487 } else {
2488 void *vptr = 0;
2489 swig_cast_info *tc;
2490
2491 /* here we get the method pointer for callbacks */
2492 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2493 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2494 if (desc)
2495 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2496 if (!desc)
2497 return SWIG_ERROR;
2498 tc = SWIG_TypeCheck(desc,ty);
2499 if (tc) {
2500 int newmemory = 0;
2501 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2502 assert(!newmemory); /* newmemory handling not yet implemented */
2503 } else {
2504 return SWIG_ERROR;
2505 }
2506 return SWIG_OK;
2507 }
2508}
2509
2510/* Convert a packed pointer value */
2511
2512SWIGRUNTIME int
2513SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2514 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2515 if (!to) return SWIG_ERROR;
2516 if (ty) {
2517 if (to != ty) {
2518 /* check type cast? */
2519 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2520 if (!tc) return SWIG_ERROR;
2521 }
2522 }
2523 return SWIG_OK;
2524}
2525
2526/* -----------------------------------------------------------------------------
2527 * Create a new pointer object
2528 * ----------------------------------------------------------------------------- */
2529
2530/*
2531 Create a new instance object, without calling __init__, and set the
2532 'this' attribute.
2533*/
2534
2535SWIGRUNTIME PyObject*
2537{
2538 PyObject *inst = 0;
2539 PyObject *newraw = data->newraw;
2540 if (newraw) {
2541 inst = PyObject_Call(newraw, data->newargs, NULL);
2542 if (inst) {
2543#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2544 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2545 if (dictptr != NULL) {
2546 PyObject *dict = *dictptr;
2547 if (dict == NULL) {
2548 dict = PyDict_New();
2549 *dictptr = dict;
2550 }
2551 if (dict) {
2552 PyDict_SetItem(dict, SWIG_This(), swig_this);
2553 } else{
2554 Py_DECREF(inst);
2555 inst = 0;
2556 }
2557 }
2558#else
2559 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2560 Py_DECREF(inst);
2561 inst = 0;
2562 }
2563#endif
2564 }
2565 } else {
2566#if PY_VERSION_HEX >= 0x03000000
2567 PyObject *empty_args = PyTuple_New(0);
2568 if (empty_args) {
2569 PyObject *empty_kwargs = PyDict_New();
2570 if (empty_kwargs) {
2571 inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
2572 Py_DECREF(empty_kwargs);
2573 if (inst) {
2574 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2575 Py_DECREF(inst);
2576 inst = 0;
2577 } else {
2578 PyType_Modified(Py_TYPE(inst));
2579 }
2580 }
2581 }
2582 Py_DECREF(empty_args);
2583 }
2584#else
2585 PyObject *dict = PyDict_New();
2586 if (dict) {
2587 PyDict_SetItem(dict, SWIG_This(), swig_this);
2588 inst = PyInstance_NewRaw(data->newargs, dict);
2589 Py_DECREF(dict);
2590 }
2591#endif
2592 }
2593 return inst;
2594}
2595
2596SWIGRUNTIME int
2597SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2598{
2599#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2600 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2601 if (dictptr != NULL) {
2602 PyObject *dict = *dictptr;
2603 if (dict == NULL) {
2604 dict = PyDict_New();
2605 *dictptr = dict;
2606 }
2607 if (dict) {
2608 return PyDict_SetItem(dict, SWIG_This(), swig_this);
2609 } else{
2610 return -1;
2611 }
2612 }
2613#endif
2614 return PyObject_SetAttr(inst, SWIG_This(), swig_this);
2615}
2616
2617
2618SWIGINTERN PyObject *
2620 PyObject *obj[2];
2621 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2622 return NULL;
2623 } else {
2624 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2625 if (sthis) {
2626 Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
2627 } else {
2628 if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
2629 return NULL;
2630 }
2631 return SWIG_Py_Void();
2632 }
2633}
2634
2635/* Create a new pointer object */
2636
2637SWIGRUNTIME PyObject *
2638SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2639 SwigPyClientData *clientdata;
2640 PyObject * robj;
2641 int own;
2642
2643 if (!ptr)
2644 return SWIG_Py_Void();
2645
2646 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2647 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2648 if (clientdata && clientdata->pytype) {
2649 SwigPyObject *newobj;
2650 if (flags & SWIG_BUILTIN_TP_INIT) {
2651 newobj = (SwigPyObject*) self;
2652 if (newobj->ptr) {
2653 PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2654 while (newobj->next)
2655 newobj = (SwigPyObject *) newobj->next;
2656 newobj->next = next_self;
2657 newobj = (SwigPyObject *)next_self;
2658#ifdef SWIGPYTHON_BUILTIN
2659 newobj->dict = 0;
2660#endif
2661 }
2662 } else {
2663 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2664#ifdef SWIGPYTHON_BUILTIN
2665 if (newobj) {
2666 newobj->dict = 0;
2667 }
2668#endif
2669 }
2670 if (newobj) {
2671 newobj->ptr = ptr;
2672 newobj->ty = type;
2673 newobj->own = own;
2674 newobj->next = 0;
2675 return (PyObject*) newobj;
2676 }
2677 return SWIG_Py_Void();
2678 }
2679
2680 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2681
2682 robj = SwigPyObject_New(ptr, type, own);
2683 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2684 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2685 Py_DECREF(robj);
2686 robj = inst;
2687 }
2688 return robj;
2689}
2690
2691/* Create a new packed object */
2692
2693SWIGRUNTIMEINLINE PyObject *
2694SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2695 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2696}
2697
2698/* -----------------------------------------------------------------------------*
2699 * Get type list
2700 * -----------------------------------------------------------------------------*/
2701
2702#ifdef SWIG_LINK_RUNTIME
2703void *SWIG_ReturnGlobalTypeList(void *);
2704#endif
2705
2706static PyObject *Swig_TypeCache_global = NULL;
2707
2708/* The python cached type query */
2709SWIGRUNTIME PyObject *
2711 if (Swig_TypeCache_global == NULL) {
2712 Swig_TypeCache_global = PyDict_New();
2713 }
2714 return Swig_TypeCache_global;
2715}
2716
2719#ifdef SWIG_LINK_RUNTIME
2720 static void *type_pointer = (void *)0;
2721 /* first check if module already created */
2722 if (!type_pointer) {
2723 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2724 }
2725#else
2726 void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2727 if (PyErr_Occurred()) {
2728 PyErr_Clear();
2729 type_pointer = (void *)0;
2730 }
2731#endif
2732 return (swig_module_info *) type_pointer;
2733}
2734
2735
2736static int interpreter_counter = 0; // how many (sub-)interpreters are using swig_module's types
2737
2738SWIGRUNTIME void
2740{
2741 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2742 swig_type_info **types = swig_module->types;
2743 size_t i;
2744 if (--interpreter_counter != 0) // another sub-interpreter may still be using the swig_module's types
2745 return;
2746 for (i =0; i < swig_module->size; ++i) {
2747 swig_type_info *ty = types[i];
2748 if (ty->owndata) {
2750 ty->clientdata = 0;
2751 if (data) SwigPyClientData_Del(data);
2752 }
2753 }
2754 Py_DECREF(SWIG_This());
2755 Swig_This_global = NULL;
2756 Py_DECREF(SWIG_globals());
2757 Swig_Globals_global = NULL;
2758 Py_DECREF(SWIG_Python_TypeCache());
2759 Swig_TypeCache_global = NULL;
2760 Swig_Capsule_global = NULL;
2761}
2762
2763SWIGRUNTIME void
2765#if PY_VERSION_HEX >= 0x03000000
2766 /* Add a dummy module object into sys.modules */
2767 PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2768#else
2769 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2770 PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2771#endif
2772 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2773 if (pointer && module) {
2774 if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
2776 Swig_Capsule_global = pointer;
2777 } else {
2778 Py_DECREF(pointer);
2779 }
2780 } else {
2781 Py_XDECREF(pointer);
2782 }
2783}
2784
2786SWIG_Python_TypeQuery(const char *type)
2787{
2788 PyObject *cache = SWIG_Python_TypeCache();
2789 PyObject *key = SWIG_Python_str_FromChar(type);
2790 PyObject *obj = PyDict_GetItem(cache, key);
2791 swig_type_info *descriptor;
2792 if (obj) {
2793 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2794 } else {
2796 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2797 if (descriptor) {
2798 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2799 if (obj) {
2800 PyDict_SetItem(cache, key, obj);
2801 Py_DECREF(obj);
2802 }
2803 }
2804 }
2805 Py_DECREF(key);
2806 return descriptor;
2807}
2808
2809/*
2810 For backward compatibility only
2811*/
2812#define SWIG_POINTER_EXCEPTION 0
2813#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2814#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2815
2816SWIGRUNTIME int
2817SWIG_Python_AddErrMesg(const char* mesg, int infront)
2818{
2819 if (PyErr_Occurred()) {
2820 PyObject *type = 0;
2821 PyObject *value = 0;
2822 PyObject *traceback = 0;
2823 PyErr_Fetch(&type, &value, &traceback);
2824 if (value) {
2825 PyObject *old_str = PyObject_Str(value);
2826 const char *tmp = SWIG_Python_str_AsChar(old_str);
2827 const char *errmesg = tmp ? tmp : "Invalid error message";
2828 Py_XINCREF(type);
2829 PyErr_Clear();
2830 if (infront) {
2831 PyErr_Format(type, "%s %s", mesg, errmesg);
2832 } else {
2833 PyErr_Format(type, "%s %s", errmesg, mesg);
2834 }
2835 Py_DECREF(old_str);
2836 }
2837 return 1;
2838 } else {
2839 return 0;
2840 }
2841}
2842
2843SWIGRUNTIME int
2845{
2846 if (PyErr_Occurred()) {
2847 /* add information about failing argument */
2848 char mesg[256];
2849 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2850 return SWIG_Python_AddErrMesg(mesg, 1);
2851 } else {
2852 return 0;
2853 }
2854}
2855
2856SWIGRUNTIMEINLINE const char *
2858{
2859 SwigPyObject *v = (SwigPyObject *)self;
2860 swig_type_info *ty = v ? v->ty : 0;
2861 return ty ? ty->str : "";
2862}
2863
2864SWIGRUNTIME void
2865SWIG_Python_TypeError(const char *type, PyObject *obj)
2866{
2867 if (type) {
2868#if defined(SWIG_COBJECT_TYPES)
2869 if (obj && SwigPyObject_Check(obj)) {
2870 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2871 if (otype) {
2872 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2873 type, otype);
2874 return;
2875 }
2876 } else
2877#endif
2878 {
2879 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2880 if (otype) {
2881 PyObject *str = PyObject_Str(obj);
2882 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2883 if (cstr) {
2884 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2885 type, otype, cstr);
2886 } else {
2887 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2888 type, otype);
2889 }
2890 Py_XDECREF(str);
2891 return;
2892 }
2893 }
2894 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2895 } else {
2896 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2897 }
2898}
2899
2900
2901/* Convert a pointer value, signal an exception on a type mismatch */
2902SWIGRUNTIME void *
2903SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2904 void *result;
2905 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2906 PyErr_Clear();
2907 }
2908 return result;
2909}
2910
2911#ifdef SWIGPYTHON_BUILTIN
2912SWIGRUNTIME int
2913SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2914 PyTypeObject *tp = obj->ob_type;
2915 PyObject *descr;
2916 PyObject *encoded_name;
2917 descrsetfunc f;
2918 int res = -1;
2919
2920# ifdef Py_USING_UNICODE
2921 if (PyString_Check(name)) {
2922 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2923 if (!name)
2924 return -1;
2925 } else if (!PyUnicode_Check(name))
2926# else
2927 if (!PyString_Check(name))
2928# endif
2929 {
2930 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2931 return -1;
2932 } else {
2933 Py_INCREF(name);
2934 }
2935
2936 if (!tp->tp_dict) {
2937 if (PyType_Ready(tp) != 0)
2938 goto done;
2939 }
2940
2941 descr = _PyType_Lookup(tp, name);
2942 f = NULL;
2943 if (descr != NULL)
2944 f = descr->ob_type->tp_descr_set;
2945 if (!f) {
2946 if (PyString_Check(name)) {
2947 encoded_name = name;
2948 Py_INCREF(name);
2949 } else {
2950 encoded_name = PyUnicode_AsUTF8String(name);
2951 if (!encoded_name)
2952 goto done;
2953 }
2954 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2955 Py_DECREF(encoded_name);
2956 } else {
2957 res = f(descr, obj, value);
2958 }
2959
2960 done:
2961 Py_DECREF(name);
2962 return res;
2963}
2964#endif
2965
2966
2967#ifdef __cplusplus
2968}
2969#endif
2970
2971
2972
2973#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2974
2975#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
2976
2977
2978
2979/* -------- TYPES TABLE (BEGIN) -------- */
2980
2981#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2982#define SWIGTYPE_p_PLcGrid swig_types[1]
2983#define SWIGTYPE_p_PLcGrid2 swig_types[2]
2984#define SWIGTYPE_p_char swig_types[3]
2985#define SWIGTYPE_p_double swig_types[4]
2986#define SWIGTYPE_p_f_double_double__int swig_types[5]
2987#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
2988#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
2989#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
2990#define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
2991#define SWIGTYPE_p_int swig_types[10]
2992#define SWIGTYPE_p_p_char swig_types[11]
2993#define SWIGTYPE_p_p_double swig_types[12]
2994#define SWIGTYPE_p_unsigned_int swig_types[13]
2996static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
2997#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2998#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2999
3000/* -------- TYPES TABLE (END) -------- */
3001
3002#ifdef SWIG_TypeQuery
3003# undef SWIG_TypeQuery
3004#endif
3005#define SWIG_TypeQuery SWIG_Python_TypeQuery
3006
3007/*-----------------------------------------------
3008 @(target):= _plplotc.so
3009 ------------------------------------------------*/
3010#if PY_VERSION_HEX >= 0x03000000
3011# define SWIG_init PyInit__plplotc
3012
3013#else
3014# define SWIG_init init_plplotc
3015
3016#endif
3017#define SWIG_name "_plplotc"
3018
3019#define SWIG_as_voidptr(a) (void *)((const void *)(a))
3020#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3021
3022
3023#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
3024#include <arrayobject.h>
3025#include "plplot.h"
3026#include "plplotP.h"
3027
3028#define NPY_PLINT NPY_INT32
3029
3030#ifdef PL_DOUBLE
3031#define NPY_PLFLT NPY_FLOAT64
3032#else
3033#define NPY_PLFLT NPY_FLOAT32
3034#endif
3035
3036// python-1.5 compatibility mode?
3037#if !defined ( PySequence_Fast_GET_ITEM )
3038 #define PySequence_Fast_GET_ITEM PySequence_GetItem
3039#endif
3040#define PySequence_Size PySequence_Length
3041
3042
3043 static PLINT Alen = 0;
3044 static PLINT Xlen = 0, Ylen = 0;
3045
3046
3047SWIGINTERN int
3048SWIG_AsVal_double (PyObject *obj, double *val)
3049{
3050 int res = SWIG_TypeError;
3051 if (PyFloat_Check(obj)) {
3052 if (val) *val = PyFloat_AsDouble(obj);
3053 return SWIG_OK;
3054#if PY_VERSION_HEX < 0x03000000
3055 } else if (PyInt_Check(obj)) {
3056 if (val) *val = (double) PyInt_AsLong(obj);
3057 return SWIG_OK;
3058#endif
3059 } else if (PyLong_Check(obj)) {
3060 double v = PyLong_AsDouble(obj);
3061 if (!PyErr_Occurred()) {
3062 if (val) *val = v;
3063 return SWIG_OK;
3064 } else {
3065 PyErr_Clear();
3066 }
3067 }
3068#ifdef SWIG_PYTHON_CAST_MODE
3069 {
3070 int dispatch = 0;
3071 double d = PyFloat_AsDouble(obj);
3072 if (!PyErr_Occurred()) {
3073 if (val) *val = d;
3074 return SWIG_AddCast(SWIG_OK);
3075 } else {
3076 PyErr_Clear();
3077 }
3078 if (!dispatch) {
3079 long v = PyLong_AsLong(obj);
3080 if (!PyErr_Occurred()) {
3081 if (val) *val = v;
3083 } else {
3084 PyErr_Clear();
3085 }
3086 }
3087 }
3088#endif
3089 return res;
3090}
3091
3092
3093 #define SWIG_From_double PyFloat_FromDouble
3094
3095
3096 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3097 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3098 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3099 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3100 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3102 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3103
3104
3105SWIGINTERNINLINE PyObject*
3107{
3108 return PyInt_FromLong((long) value);
3109}
3110
3111
3112#include <limits.h>
3113#if !defined(SWIG_NO_LLONG_MAX)
3114# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3115# define LLONG_MAX __LONG_LONG_MAX__
3116# define LLONG_MIN (-LLONG_MAX - 1LL)
3117# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3118# endif
3119#endif
3120
3121
3122#include <float.h>
3123
3124
3125#include <math.h>
3126
3127
3129SWIG_CanCastAsInteger(double *d, double min, double max) {
3130 double x = *d;
3131 if ((min <= x && x <= max)) {
3132 double fx = floor(x);
3133 double cx = ceil(x);
3134 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3135 if ((errno == EDOM) || (errno == ERANGE)) {
3136 errno = 0;
3137 } else {
3138 double summ, reps, diff;
3139 if (rd < x) {
3140 diff = x - rd;
3141 } else if (rd > x) {
3142 diff = rd - x;
3143 } else {
3144 return 1;
3145 }
3146 summ = rd + x;
3147 reps = diff/summ;
3148 if (reps < 8*DBL_EPSILON) {
3149 *d = rd;
3150 return 1;
3151 }
3152 }
3153 }
3154 return 0;
3155}
3156
3157
3158SWIGINTERN int
3159SWIG_AsVal_long (PyObject *obj, long* val)
3160{
3161#if PY_VERSION_HEX < 0x03000000
3162 if (PyInt_Check(obj)) {
3163 if (val) *val = PyInt_AsLong(obj);
3164 return SWIG_OK;
3165 } else
3166#endif
3167 if (PyLong_Check(obj)) {
3168 long v = PyLong_AsLong(obj);
3169 if (!PyErr_Occurred()) {
3170 if (val) *val = v;
3171 return SWIG_OK;
3172 } else {
3173 PyErr_Clear();
3174 return SWIG_OverflowError;
3175 }
3176 }
3177#ifdef SWIG_PYTHON_CAST_MODE
3178 {
3179 int dispatch = 0;
3180 long v = PyInt_AsLong(obj);
3181 if (!PyErr_Occurred()) {
3182 if (val) *val = v;
3183 return SWIG_AddCast(SWIG_OK);
3184 } else {
3185 PyErr_Clear();
3186 }
3187 if (!dispatch) {
3188 double d;
3189 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3190 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3191 if (val) *val = (long)(d);
3192 return res;
3193 }
3194 }
3195 }
3196#endif
3197 return SWIG_TypeError;
3198}
3199
3200
3201SWIGINTERN int
3202SWIG_AsVal_int (PyObject * obj, int *val)
3203{
3204 long v;
3205 int res = SWIG_AsVal_long (obj, &v);
3206 if (SWIG_IsOK(res)) {
3207 if ((v < INT_MIN || v > INT_MAX)) {
3208 return SWIG_OverflowError;
3209 } else {
3210 if (val) *val = (int)(v);
3211 }
3212 }
3213 return res;
3214}
3215
3216
3217SWIGINTERN int
3218SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3219{
3220#if PY_VERSION_HEX < 0x03000000
3221 if (PyInt_Check(obj)) {
3222 long v = PyInt_AsLong(obj);
3223 if (v >= 0) {
3224 if (val) *val = v;
3225 return SWIG_OK;
3226 } else {
3227 return SWIG_OverflowError;
3228 }
3229 } else
3230#endif
3231 if (PyLong_Check(obj)) {
3232 unsigned long v = PyLong_AsUnsignedLong(obj);
3233 if (!PyErr_Occurred()) {
3234 if (val) *val = v;
3235 return SWIG_OK;
3236 } else {
3237 PyErr_Clear();
3238 return SWIG_OverflowError;
3239 }
3240 }
3241#ifdef SWIG_PYTHON_CAST_MODE
3242 {
3243 int dispatch = 0;
3244 unsigned long v = PyLong_AsUnsignedLong(obj);
3245 if (!PyErr_Occurred()) {
3246 if (val) *val = v;
3247 return SWIG_AddCast(SWIG_OK);
3248 } else {
3249 PyErr_Clear();
3250 }
3251 if (!dispatch) {
3252 double d;
3253 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3254 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3255 if (val) *val = (unsigned long)(d);
3256 return res;
3257 }
3258 }
3259 }
3260#endif
3261 return SWIG_TypeError;
3262}
3263
3264
3265SWIGINTERN int
3266SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3267{
3268 unsigned long v;
3269 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3270 if (SWIG_IsOK(res)) {
3271 if ((v > UINT_MAX)) {
3272 return SWIG_OverflowError;
3273 } else {
3274 if (val) *val = (unsigned int)(v);
3275 }
3276 }
3277 return res;
3278}
3279
3280
3281SWIGINTERNINLINE PyObject*
3283{
3284 return PyInt_FromSize_t((size_t) value);
3285}
3286
3287
3290{
3291 static int init = 0;
3292 static swig_type_info* info = 0;
3293 if (!init) {
3294 info = SWIG_TypeQuery("_p_char");
3295 init = 1;
3296 }
3297 return info;
3298}
3299
3300
3301SWIGINTERN int
3302SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3303{
3304#if PY_VERSION_HEX>=0x03000000
3305#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3306 if (PyBytes_Check(obj))
3307#else
3308 if (PyUnicode_Check(obj))
3309#endif
3310#else
3311 if (PyString_Check(obj))
3312#endif
3313 {
3314 char *cstr; Py_ssize_t len;
3315 int ret = SWIG_OK;
3316#if PY_VERSION_HEX>=0x03000000
3317#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3318 if (!alloc && cptr) {
3319 /* We can't allow converting without allocation, since the internal
3320 representation of string in Python 3 is UCS-2/UCS-4 but we require
3321 a UTF-8 representation.
3322 TODO(bhy) More detailed explanation */
3323 return SWIG_RuntimeError;
3324 }
3325 obj = PyUnicode_AsUTF8String(obj);
3326 if (!obj)
3327 return SWIG_TypeError;
3328 if (alloc)
3329 *alloc = SWIG_NEWOBJ;
3330#endif
3331 if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
3332 return SWIG_TypeError;
3333#else
3334 if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
3335 return SWIG_TypeError;
3336#endif
3337 if (cptr) {
3338 if (alloc) {
3339 if (*alloc == SWIG_NEWOBJ) {
3340 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3341 *alloc = SWIG_NEWOBJ;
3342 } else {
3343 *cptr = cstr;
3344 *alloc = SWIG_OLDOBJ;
3345 }
3346 } else {
3347#if PY_VERSION_HEX>=0x03000000
3348#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3349 *cptr = PyBytes_AsString(obj);
3350#else
3351 assert(0); /* Should never reach here with Unicode strings in Python 3 */
3352#endif
3353#else
3354 *cptr = SWIG_Python_str_AsChar(obj);
3355 if (!*cptr)
3356 ret = SWIG_TypeError;
3357#endif
3358 }
3359 }
3360 if (psize) *psize = len + 1;
3361#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3362 Py_XDECREF(obj);
3363#endif
3364 return ret;
3365 } else {
3366#if defined(SWIG_PYTHON_2_UNICODE)
3367#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3368#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3369#endif
3370#if PY_VERSION_HEX<0x03000000
3371 if (PyUnicode_Check(obj)) {
3372 char *cstr; Py_ssize_t len;
3373 if (!alloc && cptr) {
3374 return SWIG_RuntimeError;
3375 }
3376 obj = PyUnicode_AsUTF8String(obj);
3377 if (!obj)
3378 return SWIG_TypeError;
3379 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3380 if (cptr) {
3381 if (alloc) *alloc = SWIG_NEWOBJ;
3382 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3383 }
3384 if (psize) *psize = len + 1;
3385
3386 Py_XDECREF(obj);
3387 return SWIG_OK;
3388 } else {
3389 Py_XDECREF(obj);
3390 }
3391 }
3392#endif
3393#endif
3394
3395 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3396 if (pchar_descriptor) {
3397 void* vptr = 0;
3398 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3399 if (cptr) *cptr = (char *) vptr;
3400 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3401 if (alloc) *alloc = SWIG_OLDOBJ;
3402 return SWIG_OK;
3403 }
3404 }
3405 }
3406 return SWIG_TypeError;
3407}
3408
3409
3410SWIGINTERN int
3411SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3412{
3413 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3414 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3415 if (SWIG_IsOK(res)) {
3416 /* special case of single char conversion when we don't need space for NUL */
3417 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3418 if (csize <= size) {
3419 if (val) {
3420 if (csize) memcpy(val, cptr, csize*sizeof(char));
3421 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3422 }
3423 if (alloc == SWIG_NEWOBJ) {
3424 free((char*)cptr);
3425 res = SWIG_DelNewMask(res);
3426 }
3427 return res;
3428 }
3429 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3430 }
3431 return SWIG_TypeError;
3432}
3433
3434
3435SWIGINTERNINLINE PyObject *
3436SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3437{
3438 if (carray) {
3439 if (size > INT_MAX) {
3440 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3441 return pchar_descriptor ?
3442 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3443 } else {
3444#if PY_VERSION_HEX >= 0x03000000
3445#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3446 return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3447#else
3448 return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3449#endif
3450#else
3451 return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3452#endif
3453 }
3454 } else {
3455 return SWIG_Py_Void();
3456 }
3457}
3458
3459
3460SWIGINTERN size_t
3461SWIG_strnlen(const char* s, size_t maxlen)
3462{
3463 const char *p;
3464 for (p = s; maxlen-- && *p; p++)
3465 ;
3466 return p - s;
3467}
3468
3469
3470
3471
3472
3473#define t_output_helper SWIG_Python_AppendOutput
3474
3475
3476SWIGINTERN int
3477SWIG_AsVal_char (PyObject * obj, char *val)
3478{
3479 int res = SWIG_AsCharArray(obj, val, 1);
3480 if (!SWIG_IsOK(res)) {
3481 long v;
3482 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3483 if (SWIG_IsOK(res)) {
3484 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3485 if (val) *val = (char)(v);
3486 } else {
3487 res = SWIG_OverflowError;
3488 }
3489 }
3490 }
3491 return res;
3492}
3493
3494#ifdef __cplusplus
3495extern "C" {
3496#endif
3497
3498 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3499
3500// some really twisted stuff to allow calling a single precision library from python
3501 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3502 {
3503 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3504 mindims, maxdims );
3505 if ( !tmp )
3506 {
3507 // could be an incoming long array which can't be "safely" converted, do it anyway
3508 if ( PyArray_Check( in ) )
3509 {
3510 PyErr_Clear();
3511 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3512 }
3513 }
3514 return tmp;
3515 }
3516
3517
3518#define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3519
3520SWIGINTERN PyObject *_wrap_pltr0(PyObject *self, PyObject *args) {
3521 PyObject *resultobj = 0;
3522 PLFLT arg1 ;
3523 PLFLT arg2 ;
3524 PLFLT *arg3 = (PLFLT *) 0 ;
3525 PLFLT *arg4 = (PLFLT *) 0 ;
3526 PLPointer arg5 = (PLPointer) 0 ;
3527 double val1 ;
3528 int ecode1 = 0 ;
3529 double val2 ;
3530 int ecode2 = 0 ;
3531 PLFLT temp3 ;
3532 int res3 = SWIG_TMPOBJ ;
3533 PLFLT temp4 ;
3534 int res4 = SWIG_TMPOBJ ;
3535 PyObject *swig_obj[2] ;
3536
3537 arg3 = &temp3;
3538 arg4 = &temp4;
3539 {
3540 arg5 = NULL;
3541 }
3542 if (!SWIG_Python_UnpackTuple(args, "pltr0", 2, 2, swig_obj)) SWIG_fail;
3543 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3544 if (!SWIG_IsOK(ecode1)) {
3545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3546 }
3547 arg1 = (PLFLT)(val1);
3548 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3549 if (!SWIG_IsOK(ecode2)) {
3550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3551 }
3552 arg2 = (PLFLT)(val2);
3553 pltr0(arg1,arg2,arg3,arg4,arg5);
3554 resultobj = SWIG_Py_Void();
3555 if (SWIG_IsTmpObj(res3)) {
3556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3557 } else {
3558 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3560 }
3561 if (SWIG_IsTmpObj(res4)) {
3562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3563 } else {
3564 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3566 }
3567 return resultobj;
3568fail:
3569 return NULL;
3570}
3571
3572
3573
3574 PyArrayObject *pltr_xg, *pltr_yg;
3577
3578 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3579 void cleanup_PLcGrid1( void );
3580 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3581 void cleanup_PLcGrid2( void );
3582
3583 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3584 {
3585 // fprintf(stderr, "marshal PLcGrid1\n");
3586 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3587 {
3588 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3589 return NULL;
3590 }
3591 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3592 NPY_PLFLT, 1, 1 );
3593 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3594 NPY_PLFLT, 1, 1 );
3595 if ( pltr_xg == 0 || pltr_yg == 0 )
3596 {
3597 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3598 return NULL;
3599 }
3600 tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3601 tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3602 if ( isimg == 0 )
3603 {
3604 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3605 {
3606 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3607 return NULL;
3608 }
3609 }
3610 else
3611 {
3612 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3613 {
3614 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3615 return NULL;
3616 }
3617 }
3618 tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3619 tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3620 return &tmpGrid1;
3621 }
3622
3623 void cleanup_PLcGrid1( void )
3624 {
3625 // fprintf(stderr, "cleanup PLcGrid1\n");
3626 Py_CLEAR( pltr_xg );
3627 Py_CLEAR( pltr_yg );
3628 }
3629
3630 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3631 {
3632 int i, size;
3633 // fprintf(stderr, "marshal PLcGrid2\n");
3634 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3635 {
3636 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3637 return NULL;
3638 }
3639 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3640 NPY_PLFLT, 2, 2 );
3641 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3642 NPY_PLFLT, 2, 2 );
3643 if ( pltr_xg == 0 || pltr_yg == 0 )
3644 {
3645 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3646 return NULL;
3647 }
3648 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3649 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3650 {
3651 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3652 return NULL;
3653 }
3654 tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3655 tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3656 if ( isimg == 0 )
3657 {
3658 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3659 {
3660 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3661 return NULL;
3662 }
3663 }
3664 else
3665 {
3666 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3667 {
3668 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3669 return NULL;
3670 }
3671 }
3672 size = tmpGrid2.ny;
3673 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3674 for ( i = 0; i < tmpGrid2.nx; i++ )
3675 tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3676 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3677 for ( i = 0; i < tmpGrid2.nx; i++ )
3678 tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3679 return &tmpGrid2;
3680 }
3681
3682 void cleanup_PLcGrid2( void )
3683 {
3684 // fprintf(stderr, "cleanup PLcGrid2\n");
3685 free( tmpGrid2.xg );
3686 free( tmpGrid2.yg );
3687 Py_CLEAR( pltr_xg );
3688 Py_CLEAR( pltr_yg );
3689 }
3690
3691SWIGINTERN PyObject *_wrap_pltr1(PyObject *self, PyObject *args) {
3692 PyObject *resultobj = 0;
3693 PLFLT arg1 ;
3694 PLFLT arg2 ;
3695 PLFLT *arg3 = (PLFLT *) 0 ;
3696 PLFLT *arg4 = (PLFLT *) 0 ;
3697 PLcGrid *arg5 = (PLcGrid *) 0 ;
3698 double val1 ;
3699 int ecode1 = 0 ;
3700 double val2 ;
3701 int ecode2 = 0 ;
3702 PLFLT temp3 ;
3703 int res3 = SWIG_TMPOBJ ;
3704 PLFLT temp4 ;
3705 int res4 = SWIG_TMPOBJ ;
3706 PyObject *swig_obj[3] ;
3707
3708 arg3 = &temp3;
3709 arg4 = &temp4;
3710 if (!SWIG_Python_UnpackTuple(args, "pltr1", 3, 3, swig_obj)) SWIG_fail;
3711 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3712 if (!SWIG_IsOK(ecode1)) {
3713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3714 }
3715 arg1 = (PLFLT)(val1);
3716 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3717 if (!SWIG_IsOK(ecode2)) {
3718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3719 }
3720 arg2 = (PLFLT)(val2);
3721 {
3722 arg5 = marshal_PLcGrid1( swig_obj[2], 0 );
3723 if ( !arg5 )
3724 return NULL;
3725 }
3726 pltr1(arg1,arg2,arg3,arg4,arg5);
3727 resultobj = SWIG_Py_Void();
3728 if (SWIG_IsTmpObj(res3)) {
3729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3730 } else {
3731 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3733 }
3734 if (SWIG_IsTmpObj(res4)) {
3735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3736 } else {
3737 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3739 }
3740 {
3742 }
3743 return resultobj;
3744fail:
3745 {
3747 }
3748 return NULL;
3749}
3750
3751
3752SWIGINTERN PyObject *_wrap_pltr2(PyObject *self, PyObject *args) {
3753 PyObject *resultobj = 0;
3754 PLFLT arg1 ;
3755 PLFLT arg2 ;
3756 PLFLT *arg3 = (PLFLT *) 0 ;
3757 PLFLT *arg4 = (PLFLT *) 0 ;
3758 PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3759 double val1 ;
3760 int ecode1 = 0 ;
3761 double val2 ;
3762 int ecode2 = 0 ;
3763 PLFLT temp3 ;
3764 int res3 = SWIG_TMPOBJ ;
3765 PLFLT temp4 ;
3766 int res4 = SWIG_TMPOBJ ;
3767 PyObject *swig_obj[3] ;
3768
3769 arg3 = &temp3;
3770 arg4 = &temp4;
3771 if (!SWIG_Python_UnpackTuple(args, "pltr2", 3, 3, swig_obj)) SWIG_fail;
3772 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3773 if (!SWIG_IsOK(ecode1)) {
3774 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3775 }
3776 arg1 = (PLFLT)(val1);
3777 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3778 if (!SWIG_IsOK(ecode2)) {
3779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3780 }
3781 arg2 = (PLFLT)(val2);
3782 {
3783 arg5 = marshal_PLcGrid2( swig_obj[2], 0 );
3784 if ( !arg5 )
3785 return NULL;
3786 }
3787 pltr2(arg1,arg2,arg3,arg4,arg5);
3788 resultobj = SWIG_Py_Void();
3789 if (SWIG_IsTmpObj(res3)) {
3790 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3791 } else {
3792 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3793 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3794 }
3795 if (SWIG_IsTmpObj(res4)) {
3796 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3797 } else {
3798 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3800 }
3801 {
3803 }
3804 return resultobj;
3805fail:
3806 {
3808 }
3809 return NULL;
3810}
3811
3812
3813
3814 // helper code for handling the callback
3815#if 0
3816 static PyInterpreterState *save_interp = NULL;
3817#endif
3819 PyObject* python_pltr = NULL;
3820 PyObject* python_f2eval = NULL;
3821 PyObject* python_ct = NULL;
3822 PyObject* python_mapform = NULL;
3823 PyObject* python_label = NULL;
3824
3825#if 0
3826#define MY_BLOCK_THREADS { \
3827 PyThreadState *prev_state, *new_state; \
3828 /* need to have started a thread at some stage */ \
3829 /* for the following to work */ \
3830 PyEval_AcquireLock(); \
3831 new_state = PyThreadState_New( save_interp ); \
3832 prev_state = PyThreadState_Swap( new_state );
3833#define MY_UNBLOCK_THREADS \
3834 new_state = PyThreadState_Swap( prev_state ); \
3835 PyThreadState_Clear( new_state ); \
3836 PyEval_ReleaseLock(); \
3837 PyThreadState_Delete( new_state ); \
3838 }
3839#else
3840#define MY_BLOCK_THREADS
3841#define MY_UNBLOCK_THREADS
3842#endif
3843
3844// Function prototypes
3845 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
3847 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
3848 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
3849 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
3850 pltr_func marshal_pltr( PyObject* input );
3851 void cleanup_pltr( void );
3852 ct_func marshal_ct( PyObject* input );
3853 void cleanup_ct( void );
3854 mapform_func marshal_mapform( PyObject* input );
3855 void cleanup_mapform( void );
3856 PLPointer marshal_PLPointer( PyObject* input, int isimg );
3857 void cleanup_PLPointer( void );
3858
3859
3860// This is the callback that gets handed to the C code. It, in turn, calls the Python callback
3861
3862 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
3863 {
3864 PyObject *pdata, *arglist, *result;
3865 PyArrayObject *tmp;
3866
3867 // the data argument is acutally a pointer to a python object
3868 pdata = (PyObject *) data;
3869 if ( data == NULL )
3870 {
3871 pdata = Py_None;
3872 }
3873 if ( python_pltr ) // if not something is terribly wrong
3874 { // hold a reference to the data object
3875 Py_XINCREF( pdata );
3876 // grab the Global Interpreter Lock to be sure threads don't mess us up
3878 // build the argument list
3879#ifdef PL_DOUBLE
3880 arglist = Py_BuildValue( "(ddO)", x, y, pdata );
3881#else
3882 arglist = Py_BuildValue( "(ffO)", x, y, pdata );
3883#endif
3884 if ( arglist == NULL )
3885 {
3886 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
3887 *tx = *ty = 0;
3888 return;
3889 }
3890 // call the python function
3891 result = PyEval_CallObject( python_pltr, arglist );
3892 // release the argument list
3893 Py_CLEAR( arglist );
3894 // check and unpack the result
3895 if ( result == NULL )
3896 {
3897 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
3898 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
3899 *tx = *ty = 0;
3900 }
3901 else
3902 {
3903 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
3904 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
3905 {
3906 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
3907 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
3908 *tx = *ty = 0;
3909 }
3910 else
3911 {
3912 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
3913 *tx = t[0];
3914 *ty = t[1];
3915 Py_CLEAR( tmp );
3916 }
3917 }
3918 // release the result
3919 Py_CLEAR( result );
3920 // release the global interpreter lock
3922 }
3923 }
3924
3926 {
3927 PyObject *pdata, *arglist, *result;
3928 PLFLT fresult = 0.0;
3929
3930 // the data argument is acutally a pointer to a python object
3931 pdata = (PyObject *) data;
3932 if ( python_f2eval ) // if not something is terribly wrong
3933 { // hold a reference to the data object
3934 Py_XINCREF( pdata );
3935 // grab the Global Interpreter Lock to be sure threads don't mess us up
3937 // build the argument list
3938 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
3939 // call the python function
3940 result = PyEval_CallObject( python_f2eval, arglist );
3941 // release the argument list
3942 Py_CLEAR( arglist );
3943 // check and unpack the result
3944 if ( !PyFloat_Check( result ) )
3945 {
3946 fprintf( stderr, "f2eval callback must return a float\n" );
3947 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
3948 }
3949 else
3950 {
3951 // should I test the type here?
3952 fresult = (PLFLT) PyFloat_AsDouble( result );
3953 }
3954 // release the result
3955 Py_CLEAR( result );
3956 // release the global interpreter lock
3958 }
3959 return fresult;
3960 }
3961
3962 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
3963 {
3964 PyObject *pdata, *arglist, *result, *unicode_string;
3965 char *pystring;
3966
3967 // the data argument is acutally a pointer to a python object
3968 if ( data )
3969 pdata = (PyObject *) data;
3970 else
3971 pdata = Py_None;
3972 if ( python_label ) // if not something is terribly wrong
3973 { // hold a reference to the data object
3974 Py_XINCREF( pdata );
3975 // grab the Global Interpreter Lock to be sure threads don't mess us up
3977 // build the argument list
3978#ifdef PL_DOUBLE
3979 arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
3980#else
3981 arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
3982#endif
3983 // call the python function
3984 result = PyEval_CallObject( python_label, arglist );
3985 // release the argument list
3986 //Py_CLEAR(arglist);
3987 // check and unpack the result
3988 if ( result == NULL )
3989 {
3990 fprintf( stderr, "label callback failed with 3 arguments\n" );
3991 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
3992 }
3993 else if ( PyString_Check( result ) )
3994 {
3995 // should I test the type here?
3996 pystring = PyString_AsString( result );
3997 strncpy( string, pystring, len );
3998 }
3999 else if ( PyUnicode_Check( result ) )
4000 {
4001 // unicode_string is never freed? memory leak here?
4002 unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
4003 pystring = PyBytes_AS_STRING( unicode_string );
4004 // len may be different then the byte string length w/ unicode?
4005 strncpy( string, pystring, len );
4006 }
4007 else
4008 {
4009 fprintf( stderr, "label callback must return a string\n" );
4010 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
4011 }
4012 // release the result
4013 Py_CLEAR( result );
4014 // release the global interpreter lock
4016 }
4017 }
4018
4019 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
4020 {
4021 PyObject *px, *py, *pdata, *arglist, *result;
4022 npy_intp n;
4023 n = 1;
4024
4025 // the data argument is acutally a pointer to a python object
4026 pdata = (PyObject *) data;
4027 if ( data == NULL )
4028 {
4029 pdata = Py_None;
4030 }
4031 if ( python_ct ) // if not something is terribly wrong
4032 { // hold a reference to the data object
4033 Py_XINCREF( pdata );
4034 // grab the Global Interpreter Lock to be sure threads don't mess us up
4036 // build the argument list
4037 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
4038 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
4039 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
4040 // call the python function
4041 result = PyEval_CallObject( python_ct, arglist );
4042 // release the argument list
4043 Py_CLEAR( arglist );
4044 Py_CLEAR( px );
4045 Py_CLEAR( py );
4046 Py_CLEAR( pdata );
4047 // check and unpack the result
4048 if ( result == NULL )
4049 {
4050 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
4051 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
4052 }
4053 // release the result
4054 Py_CLEAR( result );
4055 // release the global interpreter lock
4057 }
4058 }
4059
4061 {
4062 PyObject *px, *py, *arglist, *result;
4063 // PyArrayObject *tmpx, *tmpy;
4064// PLFLT *xx, *yy;
4065// PLINT i;
4066 npy_intp nn;
4067 nn = n;
4068
4069 if ( python_mapform ) // if not something is terribly wrong
4070 { // grab the Global Interpreter Lock to be sure threads don't mess us up
4072 // build the argument list
4073#ifdef PL_HAVE_PTHREAD
4074 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
4075 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
4076#else
4077 px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
4078 py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
4079#endif
4080 arglist = Py_BuildValue( "(iOO)", n, px, py );
4081 // call the python function
4082 result = PyEval_CallObject( python_mapform, arglist );
4083 // release the argument list
4084 Py_CLEAR( arglist );
4085 Py_CLEAR( px );
4086 Py_CLEAR( py );
4087 // check and unpack the result
4088 if ( result == NULL )
4089 {
4090 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
4091 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
4092 }
4093 // release the result
4094 Py_CLEAR( result );
4095 // release the global interpreter lock
4097 }
4098 }
4099
4100// marshal the pltr function pointer argument
4101 pltr_func marshal_pltr( PyObject* input )
4102 {
4103 pltr_func result = do_pltr_callback;
4104 PyObject * rep = PyObject_Repr( input );
4105 if ( rep )
4106 {
4107 // Memory leaks here? str and uni_str are not freed?
4108 char* str;
4109 if ( PyUnicode_Check( rep ) )
4110 {
4111 PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
4112 str = PyBytes_AS_STRING( uni_str );
4113 }
4114 else
4115 {
4116 str = PyString_AsString( rep );
4117 }
4118 if ( strstr( str, "function pltr0" ) != 0 )
4119 {
4120 result = pltr0;
4121 pltr_type = CB_0;
4122 python_pltr = NULL;
4123 }
4124 else if ( strstr( str, "function pltr1" ) != 0 )
4125 {
4126 result = pltr1;
4127 pltr_type = CB_1;
4128 python_pltr = NULL;
4129 }
4130 else if ( strstr( str, "function pltr2" ) != 0 )
4131 {
4132 result = pltr2;
4133 pltr_type = CB_2;
4134 python_pltr = NULL;
4135 }
4136 else
4137 {
4138 python_pltr = input;
4140 Py_XINCREF( input );
4141 }
4142 Py_CLEAR( rep );
4143 }
4144 else
4145 {
4146 python_pltr = input;
4148 Py_XINCREF( input );
4149 }
4150 return result;
4151 }
4152
4153 void cleanup_pltr( void )
4154 {
4155 Py_CLEAR( python_pltr );
4156 python_pltr = 0;
4157 }
4158
4159// marshal the ct function pointer argument
4160 ct_func marshal_ct( PyObject* input )
4161 {
4162 ct_func result = do_ct_callback;
4163 python_ct = input;
4164 Py_XINCREF( input );
4165 return result;
4166 }
4167
4168 void cleanup_ct( void )
4169 {
4170 Py_CLEAR( python_ct );
4171 python_ct = 0;
4172 }
4173
4174// marshal the mapform function pointer argument
4176 {
4178 python_mapform = input;
4179 Py_XINCREF( input );
4180 return result;
4181 }
4182
4183 void cleanup_mapform( void )
4184 {
4185 Py_CLEAR( python_mapform );
4186 python_mapform = 0;
4187 }
4188
4189 PLPointer marshal_PLPointer( PyObject* input, int isimg )
4190 {
4191 PLPointer result = NULL;
4192 switch ( pltr_type )
4193 {
4194 case CB_0:
4195 break;
4196 case CB_1:
4197 if ( input != Py_None )
4198 result = marshal_PLcGrid1( input, isimg );
4199 break;
4200 case CB_2:
4201 if ( input != Py_None )
4202 result = marshal_PLcGrid2( input, isimg );
4203 break;
4204 case CB_Python:
4205 Py_XINCREF( input );
4206 result = (PLPointer *) input;
4207 break;
4208 default:
4209 fprintf( stderr, "pltr_type is invalid\n" );
4210 }
4211 return result;
4212 }
4213
4215 {
4216 switch ( pltr_type )
4217 {
4218 case CB_0:
4219 break;
4220 case CB_1:
4222 break;
4223 case CB_2:
4225 break;
4226 case CB_Python:
4227 Py_CLEAR( python_pltr );
4228 break;
4229 default:
4230 fprintf( stderr, "pltr_type is invalid\n" );
4231 }
4232 python_pltr = 0;
4233 pltr_type = CB_0;
4234 }
4235
4236
4237
4238SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args) {
4239 PyObject *resultobj = 0;
4240 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4241 int arg2 ;
4242 void *argp1 = 0 ;
4243 int res1 = 0 ;
4244 int val2 ;
4245 int ecode2 = 0 ;
4246 PyObject *swig_obj[2] ;
4247
4248 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_type_set", 2, 2, swig_obj)) SWIG_fail;
4249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4250 if (!SWIG_IsOK(res1)) {
4251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4252 }
4253 arg1 = (PLGraphicsIn *)(argp1);
4254 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4255 if (!SWIG_IsOK(ecode2)) {
4256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4257 }
4258 arg2 = (int)(val2);
4259 if (arg1) (arg1)->type = arg2;
4260 resultobj = SWIG_Py_Void();
4261 return resultobj;
4262fail:
4263 return NULL;
4264}
4265
4266
4267SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args) {
4268 PyObject *resultobj = 0;
4269 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4270 void *argp1 = 0 ;
4271 int res1 = 0 ;
4272 PyObject *swig_obj[1] ;
4273 int result;
4274
4275 if (!args) SWIG_fail;
4276 swig_obj[0] = args;
4277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4278 if (!SWIG_IsOK(res1)) {
4279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4280 }
4281 arg1 = (PLGraphicsIn *)(argp1);
4282 result = (int) ((arg1)->type);
4283 resultobj = SWIG_From_int((int)(result));
4284 return resultobj;
4285fail:
4286 return NULL;
4287}
4288
4289
4290SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args) {
4291 PyObject *resultobj = 0;
4292 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4293 unsigned int arg2 ;
4294 void *argp1 = 0 ;
4295 int res1 = 0 ;
4296 unsigned int val2 ;
4297 int ecode2 = 0 ;
4298 PyObject *swig_obj[2] ;
4299
4300 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_state_set", 2, 2, swig_obj)) SWIG_fail;
4301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4302 if (!SWIG_IsOK(res1)) {
4303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4304 }
4305 arg1 = (PLGraphicsIn *)(argp1);
4306 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4307 if (!SWIG_IsOK(ecode2)) {
4308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4309 }
4310 arg2 = (unsigned int)(val2);
4311 if (arg1) (arg1)->state = arg2;
4312 resultobj = SWIG_Py_Void();
4313 return resultobj;
4314fail:
4315 return NULL;
4316}
4317
4318
4319SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args) {
4320 PyObject *resultobj = 0;
4321 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4322 void *argp1 = 0 ;
4323 int res1 = 0 ;
4324 PyObject *swig_obj[1] ;
4325 unsigned int result;
4326
4327 if (!args) SWIG_fail;
4328 swig_obj[0] = args;
4329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4330 if (!SWIG_IsOK(res1)) {
4331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4332 }
4333 arg1 = (PLGraphicsIn *)(argp1);
4334 result = (unsigned int) ((arg1)->state);
4335 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4336 return resultobj;
4337fail:
4338 return NULL;
4339}
4340
4341
4342SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args) {
4343 PyObject *resultobj = 0;
4344 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4345 unsigned int arg2 ;
4346 void *argp1 = 0 ;
4347 int res1 = 0 ;
4348 unsigned int val2 ;
4349 int ecode2 = 0 ;
4350 PyObject *swig_obj[2] ;
4351
4352 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_keysym_set", 2, 2, swig_obj)) SWIG_fail;
4353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4354 if (!SWIG_IsOK(res1)) {
4355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4356 }
4357 arg1 = (PLGraphicsIn *)(argp1);
4358 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4359 if (!SWIG_IsOK(ecode2)) {
4360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4361 }
4362 arg2 = (unsigned int)(val2);
4363 if (arg1) (arg1)->keysym = arg2;
4364 resultobj = SWIG_Py_Void();
4365 return resultobj;
4366fail:
4367 return NULL;
4368}
4369
4370
4371SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args) {
4372 PyObject *resultobj = 0;
4373 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4374 void *argp1 = 0 ;
4375 int res1 = 0 ;
4376 PyObject *swig_obj[1] ;
4377 unsigned int result;
4378
4379 if (!args) SWIG_fail;
4380 swig_obj[0] = args;
4381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4382 if (!SWIG_IsOK(res1)) {
4383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4384 }
4385 arg1 = (PLGraphicsIn *)(argp1);
4386 result = (unsigned int) ((arg1)->keysym);
4387 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4388 return resultobj;
4389fail:
4390 return NULL;
4391}
4392
4393
4394SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args) {
4395 PyObject *resultobj = 0;
4396 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4397 unsigned int arg2 ;
4398 void *argp1 = 0 ;
4399 int res1 = 0 ;
4400 unsigned int val2 ;
4401 int ecode2 = 0 ;
4402 PyObject *swig_obj[2] ;
4403
4404 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_button_set", 2, 2, swig_obj)) SWIG_fail;
4405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4406 if (!SWIG_IsOK(res1)) {
4407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4408 }
4409 arg1 = (PLGraphicsIn *)(argp1);
4410 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4411 if (!SWIG_IsOK(ecode2)) {
4412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4413 }
4414 arg2 = (unsigned int)(val2);
4415 if (arg1) (arg1)->button = arg2;
4416 resultobj = SWIG_Py_Void();
4417 return resultobj;
4418fail:
4419 return NULL;
4420}
4421
4422
4423SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args) {
4424 PyObject *resultobj = 0;
4425 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4426 void *argp1 = 0 ;
4427 int res1 = 0 ;
4428 PyObject *swig_obj[1] ;
4429 unsigned int result;
4430
4431 if (!args) SWIG_fail;
4432 swig_obj[0] = args;
4433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4434 if (!SWIG_IsOK(res1)) {
4435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4436 }
4437 arg1 = (PLGraphicsIn *)(argp1);
4438 result = (unsigned int) ((arg1)->button);
4439 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4440 return resultobj;
4441fail:
4442 return NULL;
4443}
4444
4445
4446SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args) {
4447 PyObject *resultobj = 0;
4448 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4449 PLINT arg2 ;
4450 void *argp1 = 0 ;
4451 int res1 = 0 ;
4452 int val2 ;
4453 int ecode2 = 0 ;
4454 PyObject *swig_obj[2] ;
4455
4456 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_subwindow_set", 2, 2, swig_obj)) SWIG_fail;
4457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4458 if (!SWIG_IsOK(res1)) {
4459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4460 }
4461 arg1 = (PLGraphicsIn *)(argp1);
4462 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4463 if (!SWIG_IsOK(ecode2)) {
4464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4465 }
4466 arg2 = (PLINT)(val2);
4467 if (arg1) (arg1)->subwindow = arg2;
4468 resultobj = SWIG_Py_Void();
4469 return resultobj;
4470fail:
4471 return NULL;
4472}
4473
4474
4475SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args) {
4476 PyObject *resultobj = 0;
4477 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4478 void *argp1 = 0 ;
4479 int res1 = 0 ;
4480 PyObject *swig_obj[1] ;
4481 PLINT result;
4482
4483 if (!args) SWIG_fail;
4484 swig_obj[0] = args;
4485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4486 if (!SWIG_IsOK(res1)) {
4487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4488 }
4489 arg1 = (PLGraphicsIn *)(argp1);
4490 result = (PLINT) ((arg1)->subwindow);
4491 resultobj = SWIG_From_int((int)(result));
4492 return resultobj;
4493fail:
4494 return NULL;
4495}
4496
4497
4498SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args) {
4499 PyObject *resultobj = 0;
4500 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4501 char *arg2 ;
4502 void *argp1 = 0 ;
4503 int res1 = 0 ;
4504 char temp2[16] ;
4505 int res2 ;
4506 PyObject *swig_obj[2] ;
4507
4508 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_string_set", 2, 2, swig_obj)) SWIG_fail;
4509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4510 if (!SWIG_IsOK(res1)) {
4511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4512 }
4513 arg1 = (PLGraphicsIn *)(argp1);
4514 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 16);
4515 if (!SWIG_IsOK(res2)) {
4516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4517 }
4518 arg2 = (char *)(temp2);
4519 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4520 else memset(arg1->string,0,16*sizeof(char));
4521 resultobj = SWIG_Py_Void();
4522 return resultobj;
4523fail:
4524 return NULL;
4525}
4526
4527
4528SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args) {
4529 PyObject *resultobj = 0;
4530 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4531 void *argp1 = 0 ;
4532 int res1 = 0 ;
4533 PyObject *swig_obj[1] ;
4534 char *result = 0 ;
4535
4536 if (!args) SWIG_fail;
4537 swig_obj[0] = args;
4538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4539 if (!SWIG_IsOK(res1)) {
4540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4541 }
4542 arg1 = (PLGraphicsIn *)(argp1);
4543 result = (char *)(char *) ((arg1)->string);
4544 {
4545 size_t size = SWIG_strnlen(result, 16);
4546
4547
4548
4549 resultobj = SWIG_FromCharPtrAndSize(result, size);
4550 }
4551 return resultobj;
4552fail:
4553 return NULL;
4554}
4555
4556
4557SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args) {
4558 PyObject *resultobj = 0;
4559 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4560 int arg2 ;
4561 void *argp1 = 0 ;
4562 int res1 = 0 ;
4563 int val2 ;
4564 int ecode2 = 0 ;
4565 PyObject *swig_obj[2] ;
4566
4567 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pX_set", 2, 2, swig_obj)) SWIG_fail;
4568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4569 if (!SWIG_IsOK(res1)) {
4570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4571 }
4572 arg1 = (PLGraphicsIn *)(argp1);
4573 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4574 if (!SWIG_IsOK(ecode2)) {
4575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4576 }
4577 arg2 = (int)(val2);
4578 if (arg1) (arg1)->pX = arg2;
4579 resultobj = SWIG_Py_Void();
4580 return resultobj;
4581fail:
4582 return NULL;
4583}
4584
4585
4586SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args) {
4587 PyObject *resultobj = 0;
4588 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4589 void *argp1 = 0 ;
4590 int res1 = 0 ;
4591 PyObject *swig_obj[1] ;
4592 int result;
4593
4594 if (!args) SWIG_fail;
4595 swig_obj[0] = args;
4596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4597 if (!SWIG_IsOK(res1)) {
4598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4599 }
4600 arg1 = (PLGraphicsIn *)(argp1);
4601 result = (int) ((arg1)->pX);
4602 resultobj = SWIG_From_int((int)(result));
4603 return resultobj;
4604fail:
4605 return NULL;
4606}
4607
4608
4609SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args) {
4610 PyObject *resultobj = 0;
4611 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4612 int arg2 ;
4613 void *argp1 = 0 ;
4614 int res1 = 0 ;
4615 int val2 ;
4616 int ecode2 = 0 ;
4617 PyObject *swig_obj[2] ;
4618
4619 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pY_set", 2, 2, swig_obj)) SWIG_fail;
4620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4621 if (!SWIG_IsOK(res1)) {
4622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4623 }
4624 arg1 = (PLGraphicsIn *)(argp1);
4625 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4626 if (!SWIG_IsOK(ecode2)) {
4627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4628 }
4629 arg2 = (int)(val2);
4630 if (arg1) (arg1)->pY = arg2;
4631 resultobj = SWIG_Py_Void();
4632 return resultobj;
4633fail:
4634 return NULL;
4635}
4636
4637
4638SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args) {
4639 PyObject *resultobj = 0;
4640 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4641 void *argp1 = 0 ;
4642 int res1 = 0 ;
4643 PyObject *swig_obj[1] ;
4644 int result;
4645
4646 if (!args) SWIG_fail;
4647 swig_obj[0] = args;
4648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4649 if (!SWIG_IsOK(res1)) {
4650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4651 }
4652 arg1 = (PLGraphicsIn *)(argp1);
4653 result = (int) ((arg1)->pY);
4654 resultobj = SWIG_From_int((int)(result));
4655 return resultobj;
4656fail:
4657 return NULL;
4658}
4659
4660
4661SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args) {
4662 PyObject *resultobj = 0;
4663 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4664 PLFLT arg2 ;
4665 void *argp1 = 0 ;
4666 int res1 = 0 ;
4667 double val2 ;
4668 int ecode2 = 0 ;
4669 PyObject *swig_obj[2] ;
4670
4671 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dX_set", 2, 2, swig_obj)) SWIG_fail;
4672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4673 if (!SWIG_IsOK(res1)) {
4674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4675 }
4676 arg1 = (PLGraphicsIn *)(argp1);
4677 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4678 if (!SWIG_IsOK(ecode2)) {
4679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4680 }
4681 arg2 = (PLFLT)(val2);
4682 if (arg1) (arg1)->dX = arg2;
4683 resultobj = SWIG_Py_Void();
4684 return resultobj;
4685fail:
4686 return NULL;
4687}
4688
4689
4690SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args) {
4691 PyObject *resultobj = 0;
4692 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4693 void *argp1 = 0 ;
4694 int res1 = 0 ;
4695 PyObject *swig_obj[1] ;
4696 PLFLT result;
4697
4698 if (!args) SWIG_fail;
4699 swig_obj[0] = args;
4700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4701 if (!SWIG_IsOK(res1)) {
4702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4703 }
4704 arg1 = (PLGraphicsIn *)(argp1);
4705 result = (PLFLT) ((arg1)->dX);
4706 resultobj = SWIG_From_double((double)(result));
4707 return resultobj;
4708fail:
4709 return NULL;
4710}
4711
4712
4713SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args) {
4714 PyObject *resultobj = 0;
4715 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4716 PLFLT arg2 ;
4717 void *argp1 = 0 ;
4718 int res1 = 0 ;
4719 double val2 ;
4720 int ecode2 = 0 ;
4721 PyObject *swig_obj[2] ;
4722
4723 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dY_set", 2, 2, swig_obj)) SWIG_fail;
4724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4725 if (!SWIG_IsOK(res1)) {
4726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4727 }
4728 arg1 = (PLGraphicsIn *)(argp1);
4729 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4730 if (!SWIG_IsOK(ecode2)) {
4731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4732 }
4733 arg2 = (PLFLT)(val2);
4734 if (arg1) (arg1)->dY = arg2;
4735 resultobj = SWIG_Py_Void();
4736 return resultobj;
4737fail:
4738 return NULL;
4739}
4740
4741
4742SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args) {
4743 PyObject *resultobj = 0;
4744 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4745 void *argp1 = 0 ;
4746 int res1 = 0 ;
4747 PyObject *swig_obj[1] ;
4748 PLFLT result;
4749
4750 if (!args) SWIG_fail;
4751 swig_obj[0] = args;
4752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4753 if (!SWIG_IsOK(res1)) {
4754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4755 }
4756 arg1 = (PLGraphicsIn *)(argp1);
4757 result = (PLFLT) ((arg1)->dY);
4758 resultobj = SWIG_From_double((double)(result));
4759 return resultobj;
4760fail:
4761 return NULL;
4762}
4763
4764
4765SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args) {
4766 PyObject *resultobj = 0;
4767 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4768 PLFLT arg2 ;
4769 void *argp1 = 0 ;
4770 int res1 = 0 ;
4771 double val2 ;
4772 int ecode2 = 0 ;
4773 PyObject *swig_obj[2] ;
4774
4775 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wX_set", 2, 2, swig_obj)) SWIG_fail;
4776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4777 if (!SWIG_IsOK(res1)) {
4778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4779 }
4780 arg1 = (PLGraphicsIn *)(argp1);
4781 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4782 if (!SWIG_IsOK(ecode2)) {
4783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4784 }
4785 arg2 = (PLFLT)(val2);
4786 if (arg1) (arg1)->wX = arg2;
4787 resultobj = SWIG_Py_Void();
4788 return resultobj;
4789fail:
4790 return NULL;
4791}
4792
4793
4794SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args) {
4795 PyObject *resultobj = 0;
4796 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4797 void *argp1 = 0 ;
4798 int res1 = 0 ;
4799 PyObject *swig_obj[1] ;
4800 PLFLT result;
4801
4802 if (!args) SWIG_fail;
4803 swig_obj[0] = args;
4804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4805 if (!SWIG_IsOK(res1)) {
4806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4807 }
4808 arg1 = (PLGraphicsIn *)(argp1);
4809 result = (PLFLT) ((arg1)->wX);
4810 resultobj = SWIG_From_double((double)(result));
4811 return resultobj;
4812fail:
4813 return NULL;
4814}
4815
4816
4817SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args) {
4818 PyObject *resultobj = 0;
4819 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4820 PLFLT arg2 ;
4821 void *argp1 = 0 ;
4822 int res1 = 0 ;
4823 double val2 ;
4824 int ecode2 = 0 ;
4825 PyObject *swig_obj[2] ;
4826
4827 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wY_set", 2, 2, swig_obj)) SWIG_fail;
4828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4829 if (!SWIG_IsOK(res1)) {
4830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4831 }
4832 arg1 = (PLGraphicsIn *)(argp1);
4833 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4834 if (!SWIG_IsOK(ecode2)) {
4835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
4836 }
4837 arg2 = (PLFLT)(val2);
4838 if (arg1) (arg1)->wY = arg2;
4839 resultobj = SWIG_Py_Void();
4840 return resultobj;
4841fail:
4842 return NULL;
4843}
4844
4845
4846SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args) {
4847 PyObject *resultobj = 0;
4848 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4849 void *argp1 = 0 ;
4850 int res1 = 0 ;
4851 PyObject *swig_obj[1] ;
4852 PLFLT result;
4853
4854 if (!args) SWIG_fail;
4855 swig_obj[0] = args;
4856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4857 if (!SWIG_IsOK(res1)) {
4858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4859 }
4860 arg1 = (PLGraphicsIn *)(argp1);
4861 result = (PLFLT) ((arg1)->wY);
4862 resultobj = SWIG_From_double((double)(result));
4863 return resultobj;
4864fail:
4865 return NULL;
4866}
4867
4868
4869SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *self, PyObject *args) {
4870 PyObject *resultobj = 0;
4871 PLGraphicsIn *result = 0 ;
4872
4873 if (!SWIG_Python_UnpackTuple(args, "new_PLGraphicsIn", 0, 0, 0)) SWIG_fail;
4874 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
4876 return resultobj;
4877fail:
4878 return NULL;
4879}
4880
4881
4882SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args) {
4883 PyObject *resultobj = 0;
4884 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4885 void *argp1 = 0 ;
4886 int res1 = 0 ;
4887 PyObject *swig_obj[1] ;
4888
4889 if (!args) SWIG_fail;
4890 swig_obj[0] = args;
4891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
4892 if (!SWIG_IsOK(res1)) {
4893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4894 }
4895 arg1 = (PLGraphicsIn *)(argp1);
4896 free((char *) arg1);
4897 resultobj = SWIG_Py_Void();
4898 return resultobj;
4899fail:
4900 return NULL;
4901}
4902
4903
4904SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4905 PyObject *obj;
4906 if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
4908 return SWIG_Py_Void();
4909}
4910
4911SWIGINTERN PyObject *PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4912 return SWIG_Python_InitShadowInstance(args);
4913}
4914
4915SWIGINTERN PyObject *_wrap_plsxwin(PyObject *self, PyObject *args) {
4916 PyObject *resultobj = 0;
4917 PLINT arg1 ;
4918 int val1 ;
4919 int ecode1 = 0 ;
4920 PyObject *swig_obj[1] ;
4921
4922 if (!args) SWIG_fail;
4923 swig_obj[0] = args;
4924 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4925 if (!SWIG_IsOK(ecode1)) {
4926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
4927 }
4928 arg1 = (PLINT)(val1);
4929 plsxwin(arg1);
4930 resultobj = SWIG_Py_Void();
4931 return resultobj;
4932fail:
4933 return NULL;
4934}
4935
4936
4937SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *self, PyObject *args) {
4938 PyObject *resultobj = 0;
4939 PLINT arg1 ;
4940 PLINT arg2 ;
4941 int val1 ;
4942 int ecode1 = 0 ;
4943 int val2 ;
4944 int ecode2 = 0 ;
4945 PyObject *swig_obj[2] ;
4946
4947 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelformat", 2, 2, swig_obj)) SWIG_fail;
4948 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
4949 if (!SWIG_IsOK(ecode1)) {
4950 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
4951 }
4952 arg1 = (PLINT)(val1);
4953 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4954 if (!SWIG_IsOK(ecode2)) {
4955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
4956 }
4957 arg2 = (PLINT)(val2);
4958 pl_setcontlabelformat(arg1,arg2);
4959 resultobj = SWIG_Py_Void();
4960 return resultobj;
4961fail:
4962 return NULL;
4963}
4964
4965
4966SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *self, PyObject *args) {
4967 PyObject *resultobj = 0;
4968 PLFLT arg1 ;
4969 PLFLT arg2 ;
4970 PLFLT arg3 ;
4971 PLINT arg4 ;
4972 double val1 ;
4973 int ecode1 = 0 ;
4974 double val2 ;
4975 int ecode2 = 0 ;
4976 double val3 ;
4977 int ecode3 = 0 ;
4978 int val4 ;
4979 int ecode4 = 0 ;
4980 PyObject *swig_obj[4] ;
4981
4982 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelparam", 4, 4, swig_obj)) SWIG_fail;
4983 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
4984 if (!SWIG_IsOK(ecode1)) {
4985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
4986 }
4987 arg1 = (PLFLT)(val1);
4988 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4989 if (!SWIG_IsOK(ecode2)) {
4990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
4991 }
4992 arg2 = (PLFLT)(val2);
4993 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
4994 if (!SWIG_IsOK(ecode3)) {
4995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
4996 }
4997 arg3 = (PLFLT)(val3);
4998 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
4999 if (!SWIG_IsOK(ecode4)) {
5000 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
5001 }
5002 arg4 = (PLINT)(val4);
5003 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
5004 resultobj = SWIG_Py_Void();
5005 return resultobj;
5006fail:
5007 return NULL;
5008}
5009
5010
5011SWIGINTERN PyObject *_wrap_pladv(PyObject *self, PyObject *args) {
5012 PyObject *resultobj = 0;
5013 PLINT arg1 ;
5014 int val1 ;
5015 int ecode1 = 0 ;
5016 PyObject *swig_obj[1] ;
5017
5018 if (!args) SWIG_fail;
5019 swig_obj[0] = args;
5020 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5021 if (!SWIG_IsOK(ecode1)) {
5022 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
5023 }
5024 arg1 = (PLINT)(val1);
5025 pladv(arg1);
5026 resultobj = SWIG_Py_Void();
5027 return resultobj;
5028fail:
5029 return NULL;
5030}
5031
5032
5033SWIGINTERN PyObject *_wrap_plarc(PyObject *self, PyObject *args) {
5034 PyObject *resultobj = 0;
5035 PLFLT arg1 ;
5036 PLFLT arg2 ;
5037 PLFLT arg3 ;
5038 PLFLT arg4 ;
5039 PLFLT arg5 ;
5040 PLFLT arg6 ;
5041 PLFLT arg7 ;
5042 PLBOOL arg8 ;
5043 double val1 ;
5044 int ecode1 = 0 ;
5045 double val2 ;
5046 int ecode2 = 0 ;
5047 double val3 ;
5048 int ecode3 = 0 ;
5049 double val4 ;
5050 int ecode4 = 0 ;
5051 double val5 ;
5052 int ecode5 = 0 ;
5053 double val6 ;
5054 int ecode6 = 0 ;
5055 double val7 ;
5056 int ecode7 = 0 ;
5057 int val8 ;
5058 int ecode8 = 0 ;
5059 PyObject *swig_obj[8] ;
5060
5061 if (!SWIG_Python_UnpackTuple(args, "plarc", 8, 8, swig_obj)) SWIG_fail;
5062 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5063 if (!SWIG_IsOK(ecode1)) {
5064 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
5065 }
5066 arg1 = (PLFLT)(val1);
5067 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5068 if (!SWIG_IsOK(ecode2)) {
5069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
5070 }
5071 arg2 = (PLFLT)(val2);
5072 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5073 if (!SWIG_IsOK(ecode3)) {
5074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
5075 }
5076 arg3 = (PLFLT)(val3);
5077 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5078 if (!SWIG_IsOK(ecode4)) {
5079 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
5080 }
5081 arg4 = (PLFLT)(val4);
5082 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5083 if (!SWIG_IsOK(ecode5)) {
5084 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
5085 }
5086 arg5 = (PLFLT)(val5);
5087 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5088 if (!SWIG_IsOK(ecode6)) {
5089 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
5090 }
5091 arg6 = (PLFLT)(val6);
5092 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5093 if (!SWIG_IsOK(ecode7)) {
5094 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
5095 }
5096 arg7 = (PLFLT)(val7);
5097 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5098 if (!SWIG_IsOK(ecode8)) {
5099 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
5100 }
5101 arg8 = (PLBOOL)(val8);
5102 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5103 resultobj = SWIG_Py_Void();
5104 return resultobj;
5105fail:
5106 return NULL;
5107}
5108
5109
5110SWIGINTERN PyObject *_wrap_plaxes(PyObject *self, PyObject *args) {
5111 PyObject *resultobj = 0;
5112 PLFLT arg1 ;
5113 PLFLT arg2 ;
5114 char *arg3 = (char *) 0 ;
5115 PLFLT arg4 ;
5116 PLINT arg5 ;
5117 char *arg6 = (char *) 0 ;
5118 PLFLT arg7 ;
5119 PLINT arg8 ;
5120 double val1 ;
5121 int ecode1 = 0 ;
5122 double val2 ;
5123 int ecode2 = 0 ;
5124 int res3 ;
5125 char *buf3 = 0 ;
5126 int alloc3 = 0 ;
5127 double val4 ;
5128 int ecode4 = 0 ;
5129 int val5 ;
5130 int ecode5 = 0 ;
5131 int res6 ;
5132 char *buf6 = 0 ;
5133 int alloc6 = 0 ;
5134 double val7 ;
5135 int ecode7 = 0 ;
5136 int val8 ;
5137 int ecode8 = 0 ;
5138 PyObject *swig_obj[8] ;
5139
5140 if (!SWIG_Python_UnpackTuple(args, "plaxes", 8, 8, swig_obj)) SWIG_fail;
5141 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5142 if (!SWIG_IsOK(ecode1)) {
5143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5144 }
5145 arg1 = (PLFLT)(val1);
5146 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5147 if (!SWIG_IsOK(ecode2)) {
5148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5149 }
5150 arg2 = (PLFLT)(val2);
5151 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
5152 if (!SWIG_IsOK(res3)) {
5153 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5154 }
5155 arg3 = (char *)(buf3);
5156 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5157 if (!SWIG_IsOK(ecode4)) {
5158 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5159 }
5160 arg4 = (PLFLT)(val4);
5161 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5162 if (!SWIG_IsOK(ecode5)) {
5163 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5164 }
5165 arg5 = (PLINT)(val5);
5166 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5167 if (!SWIG_IsOK(res6)) {
5168 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5169 }
5170 arg6 = (char *)(buf6);
5171 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5172 if (!SWIG_IsOK(ecode7)) {
5173 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5174 }
5175 arg7 = (PLFLT)(val7);
5176 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5177 if (!SWIG_IsOK(ecode8)) {
5178 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5179 }
5180 arg8 = (PLINT)(val8);
5181 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5182 resultobj = SWIG_Py_Void();
5183 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5184 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5185 return resultobj;
5186fail:
5187 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5188 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5189 return NULL;
5190}
5191
5192
5193SWIGINTERN PyObject *_wrap_plbin(PyObject *self, PyObject *args) {
5194 PyObject *resultobj = 0;
5195 PLINT arg1 ;
5196 PLFLT *arg2 = (PLFLT *) 0 ;
5197 PLFLT *arg3 = (PLFLT *) 0 ;
5198 PLINT arg4 ;
5199 PyArrayObject *tmp1 = NULL ;
5200 PyArrayObject *tmp3 = NULL ;
5201 int val4 ;
5202 int ecode4 = 0 ;
5203 PyObject *swig_obj[3] ;
5204
5205 if (!SWIG_Python_UnpackTuple(args, "plbin", 3, 3, swig_obj)) SWIG_fail;
5206 {
5207 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5208 if ( tmp1 == NULL )
5209 return NULL;
5210 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5211 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5212 }
5213 {
5214 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5215 if ( tmp3 == NULL )
5216 return NULL;
5217 if ( PyArray_DIMS( tmp3 )[0] != Alen )
5218 {
5219 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5220 return NULL;
5221 }
5222 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5223 }
5224 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
5225 if (!SWIG_IsOK(ecode4)) {
5226 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5227 }
5228 arg4 = (PLINT)(val4);
5229 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5230 resultobj = SWIG_Py_Void();
5231 {
5232 Py_CLEAR( tmp1 );
5233 }
5234 {
5235 Py_CLEAR( tmp3 );
5236 }
5237 return resultobj;
5238fail:
5239 {
5240 Py_CLEAR( tmp1 );
5241 }
5242 {
5243 Py_CLEAR( tmp3 );
5244 }
5245 return NULL;
5246}
5247
5248
5249SWIGINTERN PyObject *_wrap_plbtime(PyObject *self, PyObject *args) {
5250 PyObject *resultobj = 0;
5251 PLINT *arg1 = (PLINT *) 0 ;
5252 PLINT *arg2 = (PLINT *) 0 ;
5253 PLINT *arg3 = (PLINT *) 0 ;
5254 PLINT *arg4 = (PLINT *) 0 ;
5255 PLINT *arg5 = (PLINT *) 0 ;
5256 PLFLT *arg6 = (PLFLT *) 0 ;
5257 PLFLT arg7 ;
5258 PLINT temp1 ;
5259 int res1 = SWIG_TMPOBJ ;
5260 PLINT temp2 ;
5261 int res2 = SWIG_TMPOBJ ;
5262 PLINT temp3 ;
5263 int res3 = SWIG_TMPOBJ ;
5264 PLINT temp4 ;
5265 int res4 = SWIG_TMPOBJ ;
5266 PLINT temp5 ;
5267 int res5 = SWIG_TMPOBJ ;
5268 PLFLT temp6 ;
5269 int res6 = SWIG_TMPOBJ ;
5270 double val7 ;
5271 int ecode7 = 0 ;
5272 PyObject *swig_obj[1] ;
5273
5274 arg1 = &temp1;
5275 arg2 = &temp2;
5276 arg3 = &temp3;
5277 arg4 = &temp4;
5278 arg5 = &temp5;
5279 arg6 = &temp6;
5280 if (!args) SWIG_fail;
5281 swig_obj[0] = args;
5282 ecode7 = SWIG_AsVal_double(swig_obj[0], &val7);
5283 if (!SWIG_IsOK(ecode7)) {
5284 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5285 }
5286 arg7 = (PLFLT)(val7);
5287 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5288 resultobj = SWIG_Py_Void();
5289 if (SWIG_IsTmpObj(res1)) {
5290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5291 } else {
5292 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5294 }
5295 if (SWIG_IsTmpObj(res2)) {
5296 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5297 } else {
5298 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5300 }
5301 if (SWIG_IsTmpObj(res3)) {
5302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
5303 } else {
5304 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5305 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
5306 }
5307 if (SWIG_IsTmpObj(res4)) {
5308 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5309 } else {
5310 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5311 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5312 }
5313 if (SWIG_IsTmpObj(res5)) {
5314 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5315 } else {
5316 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5317 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5318 }
5319 if (SWIG_IsTmpObj(res6)) {
5320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5321 } else {
5322 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5324 }
5325 return resultobj;
5326fail:
5327 return NULL;
5328}
5329
5330
5331SWIGINTERN PyObject *_wrap_plbop(PyObject *self, PyObject *args) {
5332 PyObject *resultobj = 0;
5333
5334 if (!SWIG_Python_UnpackTuple(args, "plbop", 0, 0, 0)) SWIG_fail;
5335 plbop();
5336 resultobj = SWIG_Py_Void();
5337 return resultobj;
5338fail:
5339 return NULL;
5340}
5341
5342
5343SWIGINTERN PyObject *_wrap_plbox(PyObject *self, PyObject *args) {
5344 PyObject *resultobj = 0;
5345 char *arg1 = (char *) 0 ;
5346 PLFLT arg2 ;
5347 PLINT arg3 ;
5348 char *arg4 = (char *) 0 ;
5349 PLFLT arg5 ;
5350 PLINT arg6 ;
5351 int res1 ;
5352 char *buf1 = 0 ;
5353 int alloc1 = 0 ;
5354 double val2 ;
5355 int ecode2 = 0 ;
5356 int val3 ;
5357 int ecode3 = 0 ;
5358 int res4 ;
5359 char *buf4 = 0 ;
5360 int alloc4 = 0 ;
5361 double val5 ;
5362 int ecode5 = 0 ;
5363 int val6 ;
5364 int ecode6 = 0 ;
5365 PyObject *swig_obj[6] ;
5366
5367 if (!SWIG_Python_UnpackTuple(args, "plbox", 6, 6, swig_obj)) SWIG_fail;
5368 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5369 if (!SWIG_IsOK(res1)) {
5370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5371 }
5372 arg1 = (char *)(buf1);
5373 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5374 if (!SWIG_IsOK(ecode2)) {
5375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5376 }
5377 arg2 = (PLFLT)(val2);
5378 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5379 if (!SWIG_IsOK(ecode3)) {
5380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5381 }
5382 arg3 = (PLINT)(val3);
5383 res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
5384 if (!SWIG_IsOK(res4)) {
5385 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5386 }
5387 arg4 = (char *)(buf4);
5388 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5389 if (!SWIG_IsOK(ecode5)) {
5390 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5391 }
5392 arg5 = (PLFLT)(val5);
5393 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5394 if (!SWIG_IsOK(ecode6)) {
5395 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5396 }
5397 arg6 = (PLINT)(val6);
5398 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5399 resultobj = SWIG_Py_Void();
5400 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5401 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5402 return resultobj;
5403fail:
5404 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5405 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5406 return NULL;
5407}
5408
5409
5410SWIGINTERN PyObject *_wrap_plbox3(PyObject *self, PyObject *args) {
5411 PyObject *resultobj = 0;
5412 char *arg1 = (char *) 0 ;
5413 char *arg2 = (char *) 0 ;
5414 PLFLT arg3 ;
5415 PLINT arg4 ;
5416 char *arg5 = (char *) 0 ;
5417 char *arg6 = (char *) 0 ;
5418 PLFLT arg7 ;
5419 PLINT arg8 ;
5420 char *arg9 = (char *) 0 ;
5421 char *arg10 = (char *) 0 ;
5422 PLFLT arg11 ;
5423 PLINT arg12 ;
5424 int res1 ;
5425 char *buf1 = 0 ;
5426 int alloc1 = 0 ;
5427 int res2 ;
5428 char *buf2 = 0 ;
5429 int alloc2 = 0 ;
5430 double val3 ;
5431 int ecode3 = 0 ;
5432 int val4 ;
5433 int ecode4 = 0 ;
5434 int res5 ;
5435 char *buf5 = 0 ;
5436 int alloc5 = 0 ;
5437 int res6 ;
5438 char *buf6 = 0 ;
5439 int alloc6 = 0 ;
5440 double val7 ;
5441 int ecode7 = 0 ;
5442 int val8 ;
5443 int ecode8 = 0 ;
5444 int res9 ;
5445 char *buf9 = 0 ;
5446 int alloc9 = 0 ;
5447 int res10 ;
5448 char *buf10 = 0 ;
5449 int alloc10 = 0 ;
5450 double val11 ;
5451 int ecode11 = 0 ;
5452 int val12 ;
5453 int ecode12 = 0 ;
5454 PyObject *swig_obj[12] ;
5455
5456 if (!SWIG_Python_UnpackTuple(args, "plbox3", 12, 12, swig_obj)) SWIG_fail;
5457 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5458 if (!SWIG_IsOK(res1)) {
5459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5460 }
5461 arg1 = (char *)(buf1);
5462 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
5463 if (!SWIG_IsOK(res2)) {
5464 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5465 }
5466 arg2 = (char *)(buf2);
5467 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5468 if (!SWIG_IsOK(ecode3)) {
5469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5470 }
5471 arg3 = (PLFLT)(val3);
5472 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5473 if (!SWIG_IsOK(ecode4)) {
5474 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5475 }
5476 arg4 = (PLINT)(val4);
5477 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
5478 if (!SWIG_IsOK(res5)) {
5479 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5480 }
5481 arg5 = (char *)(buf5);
5482 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5483 if (!SWIG_IsOK(res6)) {
5484 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5485 }
5486 arg6 = (char *)(buf6);
5487 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5488 if (!SWIG_IsOK(ecode7)) {
5489 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5490 }
5491 arg7 = (PLFLT)(val7);
5492 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5493 if (!SWIG_IsOK(ecode8)) {
5494 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5495 }
5496 arg8 = (PLINT)(val8);
5497 res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
5498 if (!SWIG_IsOK(res9)) {
5499 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5500 }
5501 arg9 = (char *)(buf9);
5502 res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
5503 if (!SWIG_IsOK(res10)) {
5504 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5505 }
5506 arg10 = (char *)(buf10);
5507 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5508 if (!SWIG_IsOK(ecode11)) {
5509 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5510 }
5511 arg11 = (PLFLT)(val11);
5512 ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
5513 if (!SWIG_IsOK(ecode12)) {
5514 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5515 }
5516 arg12 = (PLINT)(val12);
5517 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);
5518 resultobj = SWIG_Py_Void();
5519 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5520 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5521 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5522 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5523 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5524 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5525 return resultobj;
5526fail:
5527 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5528 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5529 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5530 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5531 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5532 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5533 return NULL;
5534}
5535
5536
5537SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *self, PyObject *args) {
5538 PyObject *resultobj = 0;
5539 PLFLT arg1 ;
5540 PLFLT arg2 ;
5541 PLFLT *arg3 = (PLFLT *) 0 ;
5542 PLFLT *arg4 = (PLFLT *) 0 ;
5543 PLINT *arg5 = (PLINT *) 0 ;
5544 double val1 ;
5545 int ecode1 = 0 ;
5546 double val2 ;
5547 int ecode2 = 0 ;
5548 PLFLT temp3 ;
5549 int res3 = SWIG_TMPOBJ ;
5550 PLFLT temp4 ;
5551 int res4 = SWIG_TMPOBJ ;
5552 PLINT temp5 ;
5553 int res5 = SWIG_TMPOBJ ;
5554 PyObject *swig_obj[2] ;
5555
5556 arg3 = &temp3;
5557 arg4 = &temp4;
5558 arg5 = &temp5;
5559 if (!SWIG_Python_UnpackTuple(args, "plcalc_world", 2, 2, swig_obj)) SWIG_fail;
5560 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5561 if (!SWIG_IsOK(ecode1)) {
5562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5563 }
5564 arg1 = (PLFLT)(val1);
5565 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5566 if (!SWIG_IsOK(ecode2)) {
5567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5568 }
5569 arg2 = (PLFLT)(val2);
5570 plcalc_world(arg1,arg2,arg3,arg4,arg5);
5571 resultobj = SWIG_Py_Void();
5572 if (SWIG_IsTmpObj(res3)) {
5573 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5574 } else {
5575 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5576 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5577 }
5578 if (SWIG_IsTmpObj(res4)) {
5579 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5580 } else {
5581 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5582 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5583 }
5584 if (SWIG_IsTmpObj(res5)) {
5585 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5586 } else {
5587 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5588 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5589 }
5590 return resultobj;
5591fail:
5592 return NULL;
5593}
5594
5595
5596SWIGINTERN PyObject *_wrap_plclear(PyObject *self, PyObject *args) {
5597 PyObject *resultobj = 0;
5598
5599 if (!SWIG_Python_UnpackTuple(args, "plclear", 0, 0, 0)) SWIG_fail;
5600 plclear();
5601 resultobj = SWIG_Py_Void();
5602 return resultobj;
5603fail:
5604 return NULL;
5605}
5606
5607
5608SWIGINTERN PyObject *_wrap_plcol0(PyObject *self, PyObject *args) {
5609 PyObject *resultobj = 0;
5610 PLINT arg1 ;
5611 int val1 ;
5612 int ecode1 = 0 ;
5613 PyObject *swig_obj[1] ;
5614
5615 if (!args) SWIG_fail;
5616 swig_obj[0] = args;
5617 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5618 if (!SWIG_IsOK(ecode1)) {
5619 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5620 }
5621 arg1 = (PLINT)(val1);
5622 plcol0(arg1);
5623 resultobj = SWIG_Py_Void();
5624 return resultobj;
5625fail:
5626 return NULL;
5627}
5628
5629
5630SWIGINTERN PyObject *_wrap_plcol1(PyObject *self, PyObject *args) {
5631 PyObject *resultobj = 0;
5632 PLFLT arg1 ;
5633 double val1 ;
5634 int ecode1 = 0 ;
5635 PyObject *swig_obj[1] ;
5636
5637 if (!args) SWIG_fail;
5638 swig_obj[0] = args;
5639 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5640 if (!SWIG_IsOK(ecode1)) {
5641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5642 }
5643 arg1 = (PLFLT)(val1);
5644 plcol1(arg1);
5645 resultobj = SWIG_Py_Void();
5646 return resultobj;
5647fail:
5648 return NULL;
5649}
5650
5651
5652SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *self, PyObject *args) {
5653 PyObject *resultobj = 0;
5654 PLFLT arg1 ;
5655 PLFLT arg2 ;
5656 PLFLT arg3 ;
5657 PLINT arg4 ;
5658 PLBOOL arg5 ;
5659 PLINT arg6 ;
5660 PLINT arg7 ;
5661 PLINT arg8 ;
5662 PLINT arg9 ;
5663 PLINT arg10 ;
5664 PLFLT arg11 ;
5665 double val1 ;
5666 int ecode1 = 0 ;
5667 double val2 ;
5668 int ecode2 = 0 ;
5669 double val3 ;
5670 int ecode3 = 0 ;
5671 int val4 ;
5672 int ecode4 = 0 ;
5673 int val5 ;
5674 int ecode5 = 0 ;
5675 int val6 ;
5676 int ecode6 = 0 ;
5677 int val7 ;
5678 int ecode7 = 0 ;
5679 int val8 ;
5680 int ecode8 = 0 ;
5681 int val9 ;
5682 int ecode9 = 0 ;
5683 int val10 ;
5684 int ecode10 = 0 ;
5685 double val11 ;
5686 int ecode11 = 0 ;
5687 PyObject *swig_obj[11] ;
5688
5689 if (!SWIG_Python_UnpackTuple(args, "plconfigtime", 11, 11, swig_obj)) SWIG_fail;
5690 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5691 if (!SWIG_IsOK(ecode1)) {
5692 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5693 }
5694 arg1 = (PLFLT)(val1);
5695 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5696 if (!SWIG_IsOK(ecode2)) {
5697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5698 }
5699 arg2 = (PLFLT)(val2);
5700 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5701 if (!SWIG_IsOK(ecode3)) {
5702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5703 }
5704 arg3 = (PLFLT)(val3);
5705 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5706 if (!SWIG_IsOK(ecode4)) {
5707 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5708 }
5709 arg4 = (PLINT)(val4);
5710 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5711 if (!SWIG_IsOK(ecode5)) {
5712 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5713 }
5714 arg5 = (PLBOOL)(val5);
5715 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5716 if (!SWIG_IsOK(ecode6)) {
5717 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5718 }
5719 arg6 = (PLINT)(val6);
5720 ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
5721 if (!SWIG_IsOK(ecode7)) {
5722 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5723 }
5724 arg7 = (PLINT)(val7);
5725 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5726 if (!SWIG_IsOK(ecode8)) {
5727 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5728 }
5729 arg8 = (PLINT)(val8);
5730 ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
5731 if (!SWIG_IsOK(ecode9)) {
5732 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5733 }
5734 arg9 = (PLINT)(val9);
5735 ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
5736 if (!SWIG_IsOK(ecode10)) {
5737 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5738 }
5739 arg10 = (PLINT)(val10);
5740 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5741 if (!SWIG_IsOK(ecode11)) {
5742 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5743 }
5744 arg11 = (PLFLT)(val11);
5745 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5746 resultobj = SWIG_Py_Void();
5747 return resultobj;
5748fail:
5749 return NULL;
5750}
5751
5752
5753SWIGINTERN PyObject *_wrap_plcont(PyObject *self, PyObject *args) {
5754 PyObject *resultobj = 0;
5755 PLFLT **arg1 = (PLFLT **) 0 ;
5756 PLINT arg2 ;
5757 PLINT arg3 ;
5758 PLINT arg4 ;
5759 PLINT arg5 ;
5760 PLINT arg6 ;
5761 PLINT arg7 ;
5762 PLFLT *arg8 = (PLFLT *) 0 ;
5763 PLINT arg9 ;
5764 pltr_func arg10 = (pltr_func) 0 ;
5765 PLPointer arg11 = (PLPointer) 0 ;
5766 PyArrayObject *tmp1 = NULL ;
5767 int val4 ;
5768 int ecode4 = 0 ;
5769 int val5 ;
5770 int ecode5 = 0 ;
5771 int val6 ;
5772 int ecode6 = 0 ;
5773 int val7 ;
5774 int ecode7 = 0 ;
5775 PyArrayObject *tmp8 = NULL ;
5776 PyObject *swig_obj[8] ;
5777
5778 {
5779 python_pltr = 0;
5780 arg10 = NULL;
5781 }
5782 {
5783 arg11 = NULL;
5784 }
5785 if (!SWIG_Python_UnpackTuple(args, "plcont", 6, 8, swig_obj)) SWIG_fail;
5786 {
5787 int i, size;
5788 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
5789 if ( tmp1 == NULL )
5790 return NULL;
5791 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
5792 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
5793 size = arg3;
5794 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
5795 for ( i = 0; i < arg2; i++ )
5796 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
5797 }
5798 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
5799 if (!SWIG_IsOK(ecode4)) {
5800 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
5801 }
5802 arg4 = (PLINT)(val4);
5803 ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
5804 if (!SWIG_IsOK(ecode5)) {
5805 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
5806 }
5807 arg5 = (PLINT)(val5);
5808 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
5809 if (!SWIG_IsOK(ecode6)) {
5810 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
5811 }
5812 arg6 = (PLINT)(val6);
5813 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
5814 if (!SWIG_IsOK(ecode7)) {
5815 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
5816 }
5817 arg7 = (PLINT)(val7);
5818 {
5819 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
5820 if ( tmp8 == NULL )
5821 return NULL;
5822 arg9 = PyArray_DIMS( tmp8 )[0];
5823 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
5824 }
5825 if (swig_obj[6]) {
5826 {
5827 // it must be a callable or None
5828 if ( swig_obj[6] == Py_None )
5829 {
5830 arg10 = NULL;
5831 }
5832 else
5833 {
5834 if ( !PyCallable_Check( (PyObject *) swig_obj[6] ) )
5835 {
5836 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
5837 return NULL;
5838 }
5839 arg10 = marshal_pltr( swig_obj[6] );
5840 }
5841 }
5842 }
5843 if (swig_obj[7]) {
5844 {
5845 if ( swig_obj[7] == Py_None )
5846 arg11 = NULL;
5847 else
5848 {
5849 arg11 = marshal_PLPointer( swig_obj[7], 0 );
5850 }
5851 }
5852 }
5853 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
5854 resultobj = SWIG_Py_Void();
5855 {
5856 Py_CLEAR( tmp1 );
5857 free( arg1 );
5858 }
5859 {
5860 Py_CLEAR( tmp8 );
5861 }
5862 {
5863 cleanup_pltr();
5864 }
5865 {
5867 }
5868 return resultobj;
5869fail:
5870 {
5871 Py_CLEAR( tmp1 );
5872 free( arg1 );
5873 }
5874 {
5875 Py_CLEAR( tmp8 );
5876 }
5877 {
5878 cleanup_pltr();
5879 }
5880 {
5882 }
5883 return NULL;
5884}
5885
5886
5887SWIGINTERN PyObject *_wrap_plctime(PyObject *self, PyObject *args) {
5888 PyObject *resultobj = 0;
5889 PLINT arg1 ;
5890 PLINT arg2 ;
5891 PLINT arg3 ;
5892 PLINT arg4 ;
5893 PLINT arg5 ;
5894 PLFLT arg6 ;
5895 PLFLT *arg7 = (PLFLT *) 0 ;
5896 int val1 ;
5897 int ecode1 = 0 ;
5898 int val2 ;
5899 int ecode2 = 0 ;
5900 int val3 ;
5901 int ecode3 = 0 ;
5902 int val4 ;
5903 int ecode4 = 0 ;
5904 int val5 ;
5905 int ecode5 = 0 ;
5906 double val6 ;
5907 int ecode6 = 0 ;
5908 PLFLT temp7 ;
5909 int res7 = SWIG_TMPOBJ ;
5910 PyObject *swig_obj[6] ;
5911
5912 arg7 = &temp7;
5913 if (!SWIG_Python_UnpackTuple(args, "plctime", 6, 6, swig_obj)) SWIG_fail;
5914 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5915 if (!SWIG_IsOK(ecode1)) {
5916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
5917 }
5918 arg1 = (PLINT)(val1);
5919 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5920 if (!SWIG_IsOK(ecode2)) {
5921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
5922 }
5923 arg2 = (PLINT)(val2);
5924 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5925 if (!SWIG_IsOK(ecode3)) {
5926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
5927 }
5928 arg3 = (PLINT)(val3);
5929 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5930 if (!SWIG_IsOK(ecode4)) {
5931 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
5932 }
5933 arg4 = (PLINT)(val4);
5934 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5935 if (!SWIG_IsOK(ecode5)) {
5936 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
5937 }
5938 arg5 = (PLINT)(val5);
5939 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5940 if (!SWIG_IsOK(ecode6)) {
5941 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
5942 }
5943 arg6 = (PLFLT)(val6);
5944 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5945 resultobj = SWIG_Py_Void();
5946 if (SWIG_IsTmpObj(res7)) {
5947 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
5948 } else {
5949 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5950 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
5951 }
5952 return resultobj;
5953fail:
5954 return NULL;
5955}
5956
5957
5958SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *self, PyObject *args) {
5959 PyObject *resultobj = 0;
5960 PLINT arg1 ;
5961 PLBOOL arg2 ;
5962 int val1 ;
5963 int ecode1 = 0 ;
5964 int val2 ;
5965 int ecode2 = 0 ;
5966 PyObject *swig_obj[2] ;
5967
5968 if (!SWIG_Python_UnpackTuple(args, "plcpstrm", 2, 2, swig_obj)) SWIG_fail;
5969 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5970 if (!SWIG_IsOK(ecode1)) {
5971 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
5972 }
5973 arg1 = (PLINT)(val1);
5974 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5975 if (!SWIG_IsOK(ecode2)) {
5976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
5977 }
5978 arg2 = (PLBOOL)(val2);
5979 plcpstrm(arg1,arg2);
5980 resultobj = SWIG_Py_Void();
5981 return resultobj;
5982fail:
5983 return NULL;
5984}
5985
5986
5987SWIGINTERN PyObject *_wrap_plend(PyObject *self, PyObject *args) {
5988 PyObject *resultobj = 0;
5989
5990 if (!SWIG_Python_UnpackTuple(args, "plend", 0, 0, 0)) SWIG_fail;
5991 plend();
5992 resultobj = SWIG_Py_Void();
5993 return resultobj;
5994fail:
5995 return NULL;
5996}
5997
5998
5999SWIGINTERN PyObject *_wrap_plend1(PyObject *self, PyObject *args) {
6000 PyObject *resultobj = 0;
6001
6002 if (!SWIG_Python_UnpackTuple(args, "plend1", 0, 0, 0)) SWIG_fail;
6003 plend1();
6004 resultobj = SWIG_Py_Void();
6005 return resultobj;
6006fail:
6007 return NULL;
6008}
6009
6010
6011SWIGINTERN PyObject *_wrap_plenv(PyObject *self, PyObject *args) {
6012 PyObject *resultobj = 0;
6013 PLFLT arg1 ;
6014 PLFLT arg2 ;
6015 PLFLT arg3 ;
6016 PLFLT arg4 ;
6017 PLINT arg5 ;
6018 PLINT arg6 ;
6019 double val1 ;
6020 int ecode1 = 0 ;
6021 double val2 ;
6022 int ecode2 = 0 ;
6023 double val3 ;
6024 int ecode3 = 0 ;
6025 double val4 ;
6026 int ecode4 = 0 ;
6027 int val5 ;
6028 int ecode5 = 0 ;
6029 int val6 ;
6030 int ecode6 = 0 ;
6031 PyObject *swig_obj[6] ;
6032
6033 if (!SWIG_Python_UnpackTuple(args, "plenv", 6, 6, swig_obj)) SWIG_fail;
6034 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6035 if (!SWIG_IsOK(ecode1)) {
6036 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
6037 }
6038 arg1 = (PLFLT)(val1);
6039 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6040 if (!SWIG_IsOK(ecode2)) {
6041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
6042 }
6043 arg2 = (PLFLT)(val2);
6044 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6045 if (!SWIG_IsOK(ecode3)) {
6046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
6047 }
6048 arg3 = (PLFLT)(val3);
6049 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6050 if (!SWIG_IsOK(ecode4)) {
6051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
6052 }
6053 arg4 = (PLFLT)(val4);
6054 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6055 if (!SWIG_IsOK(ecode5)) {
6056 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
6057 }
6058 arg5 = (PLINT)(val5);
6059 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6060 if (!SWIG_IsOK(ecode6)) {
6061 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6062 }
6063 arg6 = (PLINT)(val6);
6064 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6065 resultobj = SWIG_Py_Void();
6066 return resultobj;
6067fail:
6068 return NULL;
6069}
6070
6071
6072SWIGINTERN PyObject *_wrap_plenv0(PyObject *self, PyObject *args) {
6073 PyObject *resultobj = 0;
6074 PLFLT arg1 ;
6075 PLFLT arg2 ;
6076 PLFLT arg3 ;
6077 PLFLT arg4 ;
6078 PLINT arg5 ;
6079 PLINT arg6 ;
6080 double val1 ;
6081 int ecode1 = 0 ;
6082 double val2 ;
6083 int ecode2 = 0 ;
6084 double val3 ;
6085 int ecode3 = 0 ;
6086 double val4 ;
6087 int ecode4 = 0 ;
6088 int val5 ;
6089 int ecode5 = 0 ;
6090 int val6 ;
6091 int ecode6 = 0 ;
6092 PyObject *swig_obj[6] ;
6093
6094 if (!SWIG_Python_UnpackTuple(args, "plenv0", 6, 6, swig_obj)) SWIG_fail;
6095 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6096 if (!SWIG_IsOK(ecode1)) {
6097 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6098 }
6099 arg1 = (PLFLT)(val1);
6100 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6101 if (!SWIG_IsOK(ecode2)) {
6102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6103 }
6104 arg2 = (PLFLT)(val2);
6105 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6106 if (!SWIG_IsOK(ecode3)) {
6107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6108 }
6109 arg3 = (PLFLT)(val3);
6110 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6111 if (!SWIG_IsOK(ecode4)) {
6112 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6113 }
6114 arg4 = (PLFLT)(val4);
6115 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6116 if (!SWIG_IsOK(ecode5)) {
6117 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6118 }
6119 arg5 = (PLINT)(val5);
6120 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6121 if (!SWIG_IsOK(ecode6)) {
6122 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6123 }
6124 arg6 = (PLINT)(val6);
6125 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6126 resultobj = SWIG_Py_Void();
6127 return resultobj;
6128fail:
6129 return NULL;
6130}
6131
6132
6133SWIGINTERN PyObject *_wrap_pleop(PyObject *self, PyObject *args) {
6134 PyObject *resultobj = 0;
6135
6136 if (!SWIG_Python_UnpackTuple(args, "pleop", 0, 0, 0)) SWIG_fail;
6137 pleop();
6138 resultobj = SWIG_Py_Void();
6139 return resultobj;
6140fail:
6141 return NULL;
6142}
6143
6144
6145SWIGINTERN PyObject *_wrap_plerrx(PyObject *self, PyObject *args) {
6146 PyObject *resultobj = 0;
6147 PLINT arg1 ;
6148 PLFLT *arg2 = (PLFLT *) 0 ;
6149 PLFLT *arg3 = (PLFLT *) 0 ;
6150 PLFLT *arg4 = (PLFLT *) 0 ;
6151 PyArrayObject *tmp1 = NULL ;
6152 PyArrayObject *tmp3 = NULL ;
6153 PyArrayObject *tmp4 = NULL ;
6154 PyObject *swig_obj[3] ;
6155
6156 if (!SWIG_Python_UnpackTuple(args, "plerrx", 3, 3, swig_obj)) SWIG_fail;
6157 {
6158 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6159 if ( tmp1 == NULL )
6160 return NULL;
6161 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6162 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6163 }
6164 {
6165 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6166 if ( tmp3 == NULL )
6167 return NULL;
6168 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6169 {
6170 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6171 return NULL;
6172 }
6173 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6174 }
6175 {
6176 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6177 if ( tmp4 == NULL )
6178 return NULL;
6179 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6180 {
6181 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6182 return NULL;
6183 }
6184 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6185 }
6186 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6187 resultobj = SWIG_Py_Void();
6188 {
6189 Py_CLEAR( tmp1 );
6190 }
6191 {
6192 Py_CLEAR( tmp3 );
6193 }
6194 {
6195 Py_CLEAR( tmp4 );
6196 }
6197 return resultobj;
6198fail:
6199 {
6200 Py_CLEAR( tmp1 );
6201 }
6202 {
6203 Py_CLEAR( tmp3 );
6204 }
6205 {
6206 Py_CLEAR( tmp4 );
6207 }
6208 return NULL;
6209}
6210
6211
6212SWIGINTERN PyObject *_wrap_plerry(PyObject *self, PyObject *args) {
6213 PyObject *resultobj = 0;
6214 PLINT arg1 ;
6215 PLFLT *arg2 = (PLFLT *) 0 ;
6216 PLFLT *arg3 = (PLFLT *) 0 ;
6217 PLFLT *arg4 = (PLFLT *) 0 ;
6218 PyArrayObject *tmp1 = NULL ;
6219 PyArrayObject *tmp3 = NULL ;
6220 PyArrayObject *tmp4 = NULL ;
6221 PyObject *swig_obj[3] ;
6222
6223 if (!SWIG_Python_UnpackTuple(args, "plerry", 3, 3, swig_obj)) SWIG_fail;
6224 {
6225 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6226 if ( tmp1 == NULL )
6227 return NULL;
6228 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6229 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6230 }
6231 {
6232 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6233 if ( tmp3 == NULL )
6234 return NULL;
6235 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6236 {
6237 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6238 return NULL;
6239 }
6240 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6241 }
6242 {
6243 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6244 if ( tmp4 == NULL )
6245 return NULL;
6246 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6247 {
6248 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6249 return NULL;
6250 }
6251 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6252 }
6253 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6254 resultobj = SWIG_Py_Void();
6255 {
6256 Py_CLEAR( tmp1 );
6257 }
6258 {
6259 Py_CLEAR( tmp3 );
6260 }
6261 {
6262 Py_CLEAR( tmp4 );
6263 }
6264 return resultobj;
6265fail:
6266 {
6267 Py_CLEAR( tmp1 );
6268 }
6269 {
6270 Py_CLEAR( tmp3 );
6271 }
6272 {
6273 Py_CLEAR( tmp4 );
6274 }
6275 return NULL;
6276}
6277
6278
6279SWIGINTERN PyObject *_wrap_plfamadv(PyObject *self, PyObject *args) {
6280 PyObject *resultobj = 0;
6281
6282 if (!SWIG_Python_UnpackTuple(args, "plfamadv", 0, 0, 0)) SWIG_fail;
6283 plfamadv();
6284 resultobj = SWIG_Py_Void();
6285 return resultobj;
6286fail:
6287 return NULL;
6288}
6289
6290
6291SWIGINTERN PyObject *_wrap_plfill(PyObject *self, PyObject *args) {
6292 PyObject *resultobj = 0;
6293 PLINT arg1 ;
6294 PLFLT *arg2 = (PLFLT *) 0 ;
6295 PLFLT *arg3 = (PLFLT *) 0 ;
6296 PyArrayObject *tmp1 = NULL ;
6297 PyArrayObject *tmp3 = NULL ;
6298 PyObject *swig_obj[2] ;
6299
6300 if (!SWIG_Python_UnpackTuple(args, "plfill", 2, 2, swig_obj)) SWIG_fail;
6301 {
6302 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6303 if ( tmp1 == NULL )
6304 return NULL;
6305 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6306 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6307 }
6308 {
6309 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6310 if ( tmp3 == NULL )
6311 return NULL;
6312 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6313 {
6314 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6315 return NULL;
6316 }
6317 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6318 }
6319 plfill(arg1,(double const *)arg2,(double const *)arg3);
6320 resultobj = SWIG_Py_Void();
6321 {
6322 Py_CLEAR( tmp1 );
6323 }
6324 {
6325 Py_CLEAR( tmp3 );
6326 }
6327 return resultobj;
6328fail:
6329 {
6330 Py_CLEAR( tmp1 );
6331 }
6332 {
6333 Py_CLEAR( tmp3 );
6334 }
6335 return NULL;
6336}
6337
6338
6339SWIGINTERN PyObject *_wrap_plfill3(PyObject *self, PyObject *args) {
6340 PyObject *resultobj = 0;
6341 PLINT arg1 ;
6342 PLFLT *arg2 = (PLFLT *) 0 ;
6343 PLFLT *arg3 = (PLFLT *) 0 ;
6344 PLFLT *arg4 = (PLFLT *) 0 ;
6345 PyArrayObject *tmp1 = NULL ;
6346 PyArrayObject *tmp3 = NULL ;
6347 PyArrayObject *tmp4 = NULL ;
6348 PyObject *swig_obj[3] ;
6349
6350 if (!SWIG_Python_UnpackTuple(args, "plfill3", 3, 3, swig_obj)) SWIG_fail;
6351 {
6352 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6353 if ( tmp1 == NULL )
6354 return NULL;
6355 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6356 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6357 }
6358 {
6359 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6360 if ( tmp3 == NULL )
6361 return NULL;
6362 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6363 {
6364 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6365 return NULL;
6366 }
6367 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6368 }
6369 {
6370 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6371 if ( tmp4 == NULL )
6372 return NULL;
6373 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6374 {
6375 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6376 return NULL;
6377 }
6378 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6379 }
6380 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6381 resultobj = SWIG_Py_Void();
6382 {
6383 Py_CLEAR( tmp1 );
6384 }
6385 {
6386 Py_CLEAR( tmp3 );
6387 }
6388 {
6389 Py_CLEAR( tmp4 );
6390 }
6391 return resultobj;
6392fail:
6393 {
6394 Py_CLEAR( tmp1 );
6395 }
6396 {
6397 Py_CLEAR( tmp3 );
6398 }
6399 {
6400 Py_CLEAR( tmp4 );
6401 }
6402 return NULL;
6403}
6404
6405
6406SWIGINTERN PyObject *_wrap_plgradient(PyObject *self, PyObject *args) {
6407 PyObject *resultobj = 0;
6408 PLINT arg1 ;
6409 PLFLT *arg2 = (PLFLT *) 0 ;
6410 PLFLT *arg3 = (PLFLT *) 0 ;
6411 PLFLT arg4 ;
6412 PyArrayObject *tmp1 = NULL ;
6413 PyArrayObject *tmp3 = NULL ;
6414 double val4 ;
6415 int ecode4 = 0 ;
6416 PyObject *swig_obj[3] ;
6417
6418 if (!SWIG_Python_UnpackTuple(args, "plgradient", 3, 3, swig_obj)) SWIG_fail;
6419 {
6420 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6421 if ( tmp1 == NULL )
6422 return NULL;
6423 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6424 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6425 }
6426 {
6427 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6428 if ( tmp3 == NULL )
6429 return NULL;
6430 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6431 {
6432 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6433 return NULL;
6434 }
6435 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6436 }
6437 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
6438 if (!SWIG_IsOK(ecode4)) {
6439 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6440 }
6441 arg4 = (PLFLT)(val4);
6442 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6443 resultobj = SWIG_Py_Void();
6444 {
6445 Py_CLEAR( tmp1 );
6446 }
6447 {
6448 Py_CLEAR( tmp3 );
6449 }
6450 return resultobj;
6451fail:
6452 {
6453 Py_CLEAR( tmp1 );
6454 }
6455 {
6456 Py_CLEAR( tmp3 );
6457 }
6458 return NULL;
6459}
6460
6461
6462SWIGINTERN PyObject *_wrap_plflush(PyObject *self, PyObject *args) {
6463 PyObject *resultobj = 0;
6464
6465 if (!SWIG_Python_UnpackTuple(args, "plflush", 0, 0, 0)) SWIG_fail;
6466 plflush();
6467 resultobj = SWIG_Py_Void();
6468 return resultobj;
6469fail:
6470 return NULL;
6471}
6472
6473
6474SWIGINTERN PyObject *_wrap_plfont(PyObject *self, PyObject *args) {
6475 PyObject *resultobj = 0;
6476 PLINT arg1 ;
6477 int val1 ;
6478 int ecode1 = 0 ;
6479 PyObject *swig_obj[1] ;
6480
6481 if (!args) SWIG_fail;
6482 swig_obj[0] = args;
6483 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6484 if (!SWIG_IsOK(ecode1)) {
6485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6486 }
6487 arg1 = (PLINT)(val1);
6488 plfont(arg1);
6489 resultobj = SWIG_Py_Void();
6490 return resultobj;
6491fail:
6492 return NULL;
6493}
6494
6495
6496SWIGINTERN PyObject *_wrap_plfontld(PyObject *self, PyObject *args) {
6497 PyObject *resultobj = 0;
6498 PLINT arg1 ;
6499 int val1 ;
6500 int ecode1 = 0 ;
6501 PyObject *swig_obj[1] ;
6502
6503 if (!args) SWIG_fail;
6504 swig_obj[0] = args;
6505 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6506 if (!SWIG_IsOK(ecode1)) {
6507 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6508 }
6509 arg1 = (PLINT)(val1);
6510 plfontld(arg1);
6511 resultobj = SWIG_Py_Void();
6512 return resultobj;
6513fail:
6514 return NULL;
6515}
6516
6517
6518SWIGINTERN PyObject *_wrap_plgchr(PyObject *self, PyObject *args) {
6519 PyObject *resultobj = 0;
6520 PLFLT *arg1 = (PLFLT *) 0 ;
6521 PLFLT *arg2 = (PLFLT *) 0 ;
6522 PLFLT temp1 ;
6523 int res1 = SWIG_TMPOBJ ;
6524 PLFLT temp2 ;
6525 int res2 = SWIG_TMPOBJ ;
6526
6527 arg1 = &temp1;
6528 arg2 = &temp2;
6529 if (!SWIG_Python_UnpackTuple(args, "plgchr", 0, 0, 0)) SWIG_fail;
6530 plgchr(arg1,arg2);
6531 resultobj = SWIG_Py_Void();
6532 if (SWIG_IsTmpObj(res1)) {
6533 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6534 } else {
6535 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6537 }
6538 if (SWIG_IsTmpObj(res2)) {
6539 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6540 } else {
6541 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6542 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6543 }
6544 return resultobj;
6545fail:
6546 return NULL;
6547}
6548
6549
6550SWIGINTERN PyObject *_wrap_plgcol0(PyObject *self, PyObject *args) {
6551 PyObject *resultobj = 0;
6552 PLINT arg1 ;
6553 PLINT *arg2 = (PLINT *) 0 ;
6554 PLINT *arg3 = (PLINT *) 0 ;
6555 PLINT *arg4 = (PLINT *) 0 ;
6556 int val1 ;
6557 int ecode1 = 0 ;
6558 PLINT temp2 ;
6559 int res2 = SWIG_TMPOBJ ;
6560 PLINT temp3 ;
6561 int res3 = SWIG_TMPOBJ ;
6562 PLINT temp4 ;
6563 int res4 = SWIG_TMPOBJ ;
6564 PyObject *swig_obj[1] ;
6565
6566 arg2 = &temp2;
6567 arg3 = &temp3;
6568 arg4 = &temp4;
6569 if (!args) SWIG_fail;
6570 swig_obj[0] = args;
6571 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6572 if (!SWIG_IsOK(ecode1)) {
6573 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6574 }
6575 arg1 = (PLINT)(val1);
6576 plgcol0(arg1,arg2,arg3,arg4);
6577 resultobj = SWIG_Py_Void();
6578 if (SWIG_IsTmpObj(res2)) {
6579 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6580 } else {
6581 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6582 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6583 }
6584 if (SWIG_IsTmpObj(res3)) {
6585 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6586 } else {
6587 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6588 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6589 }
6590 if (SWIG_IsTmpObj(res4)) {
6591 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6592 } else {
6593 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6594 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6595 }
6596 return resultobj;
6597fail:
6598 return NULL;
6599}
6600
6601
6602SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *self, PyObject *args) {
6603 PyObject *resultobj = 0;
6604 PLINT arg1 ;
6605 PLINT *arg2 = (PLINT *) 0 ;
6606 PLINT *arg3 = (PLINT *) 0 ;
6607 PLINT *arg4 = (PLINT *) 0 ;
6608 PLFLT *arg5 = (PLFLT *) 0 ;
6609 int val1 ;
6610 int ecode1 = 0 ;
6611 PLINT temp2 ;
6612 int res2 = SWIG_TMPOBJ ;
6613 PLINT temp3 ;
6614 int res3 = SWIG_TMPOBJ ;
6615 PLINT temp4 ;
6616 int res4 = SWIG_TMPOBJ ;
6617 PLFLT temp5 ;
6618 int res5 = SWIG_TMPOBJ ;
6619 PyObject *swig_obj[1] ;
6620
6621 arg2 = &temp2;
6622 arg3 = &temp3;
6623 arg4 = &temp4;
6624 arg5 = &temp5;
6625 if (!args) SWIG_fail;
6626 swig_obj[0] = args;
6627 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6628 if (!SWIG_IsOK(ecode1)) {
6629 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6630 }
6631 arg1 = (PLINT)(val1);
6632 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6633 resultobj = SWIG_Py_Void();
6634 if (SWIG_IsTmpObj(res2)) {
6635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6636 } else {
6637 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6639 }
6640 if (SWIG_IsTmpObj(res3)) {
6641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6642 } else {
6643 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6645 }
6646 if (SWIG_IsTmpObj(res4)) {
6647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6648 } else {
6649 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6650 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6651 }
6652 if (SWIG_IsTmpObj(res5)) {
6653 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6654 } else {
6655 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6656 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6657 }
6658 return resultobj;
6659fail:
6660 return NULL;
6661}
6662
6663
6664SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *self, PyObject *args) {
6665 PyObject *resultobj = 0;
6666 PLINT *arg1 = (PLINT *) 0 ;
6667 PLINT *arg2 = (PLINT *) 0 ;
6668 PLINT *arg3 = (PLINT *) 0 ;
6669 PLINT temp1 ;
6670 int res1 = SWIG_TMPOBJ ;
6671 PLINT temp2 ;
6672 int res2 = SWIG_TMPOBJ ;
6673 PLINT temp3 ;
6674 int res3 = SWIG_TMPOBJ ;
6675
6676 arg1 = &temp1;
6677 arg2 = &temp2;
6678 arg3 = &temp3;
6679 if (!SWIG_Python_UnpackTuple(args, "plgcolbg", 0, 0, 0)) SWIG_fail;
6680 plgcolbg(arg1,arg2,arg3);
6681 resultobj = SWIG_Py_Void();
6682 if (SWIG_IsTmpObj(res1)) {
6683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6684 } else {
6685 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6686 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6687 }
6688 if (SWIG_IsTmpObj(res2)) {
6689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6690 } else {
6691 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6693 }
6694 if (SWIG_IsTmpObj(res3)) {
6695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6696 } else {
6697 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6699 }
6700 return resultobj;
6701fail:
6702 return NULL;
6703}
6704
6705
6706SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *self, PyObject *args) {
6707 PyObject *resultobj = 0;
6708 PLINT *arg1 = (PLINT *) 0 ;
6709 PLINT *arg2 = (PLINT *) 0 ;
6710 PLINT *arg3 = (PLINT *) 0 ;
6711 PLFLT *arg4 = (PLFLT *) 0 ;
6712 PLINT temp1 ;
6713 int res1 = SWIG_TMPOBJ ;
6714 PLINT temp2 ;
6715 int res2 = SWIG_TMPOBJ ;
6716 PLINT temp3 ;
6717 int res3 = SWIG_TMPOBJ ;
6718 PLFLT temp4 ;
6719 int res4 = SWIG_TMPOBJ ;
6720
6721 arg1 = &temp1;
6722 arg2 = &temp2;
6723 arg3 = &temp3;
6724 arg4 = &temp4;
6725 if (!SWIG_Python_UnpackTuple(args, "plgcolbga", 0, 0, 0)) SWIG_fail;
6726 plgcolbga(arg1,arg2,arg3,arg4);
6727 resultobj = SWIG_Py_Void();
6728 if (SWIG_IsTmpObj(res1)) {
6729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6730 } else {
6731 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6733 }
6734 if (SWIG_IsTmpObj(res2)) {
6735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6736 } else {
6737 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6739 }
6740 if (SWIG_IsTmpObj(res3)) {
6741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6742 } else {
6743 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6745 }
6746 if (SWIG_IsTmpObj(res4)) {
6747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6748 } else {
6749 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6751 }
6752 return resultobj;
6753fail:
6754 return NULL;
6755}
6756
6757
6758SWIGINTERN PyObject *_wrap_plgcompression(PyObject *self, PyObject *args) {
6759 PyObject *resultobj = 0;
6760 PLINT *arg1 = (PLINT *) 0 ;
6761 PLINT temp1 ;
6762 int res1 = SWIG_TMPOBJ ;
6763
6764 arg1 = &temp1;
6765 if (!SWIG_Python_UnpackTuple(args, "plgcompression", 0, 0, 0)) SWIG_fail;
6766 plgcompression(arg1);
6767 resultobj = SWIG_Py_Void();
6768 if (SWIG_IsTmpObj(res1)) {
6769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6770 } else {
6771 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6773 }
6774 return resultobj;
6775fail:
6776 return NULL;
6777}
6778
6779
6780SWIGINTERN PyObject *_wrap_plgdev(PyObject *self, PyObject *args) {
6781 PyObject *resultobj = 0;
6782 char *arg1 = (char *) 0 ;
6783 char buff1[1000] ;
6784
6785 {
6786 arg1 = buff1;
6787 }
6788 if (!SWIG_Python_UnpackTuple(args, "plgdev", 0, 0, 0)) SWIG_fail;
6789 plgdev(arg1);
6790 resultobj = SWIG_Py_Void();
6791 {
6792 PyObject *o = PyString_FromString( arg1 );
6793 resultobj = t_output_helper( resultobj, o );
6794 }
6795 return resultobj;
6796fail:
6797 return NULL;
6798}
6799
6800
6801SWIGINTERN PyObject *_wrap_plgdidev(PyObject *self, PyObject *args) {
6802 PyObject *resultobj = 0;
6803 PLFLT *arg1 = (PLFLT *) 0 ;
6804 PLFLT *arg2 = (PLFLT *) 0 ;
6805 PLFLT *arg3 = (PLFLT *) 0 ;
6806 PLFLT *arg4 = (PLFLT *) 0 ;
6807 PLFLT temp1 ;
6808 int res1 = SWIG_TMPOBJ ;
6809 PLFLT temp2 ;
6810 int res2 = SWIG_TMPOBJ ;
6811 PLFLT temp3 ;
6812 int res3 = SWIG_TMPOBJ ;
6813 PLFLT temp4 ;
6814 int res4 = SWIG_TMPOBJ ;
6815
6816 arg1 = &temp1;
6817 arg2 = &temp2;
6818 arg3 = &temp3;
6819 arg4 = &temp4;
6820 if (!SWIG_Python_UnpackTuple(args, "plgdidev", 0, 0, 0)) SWIG_fail;
6821 plgdidev(arg1,arg2,arg3,arg4);
6822 resultobj = SWIG_Py_Void();
6823 if (SWIG_IsTmpObj(res1)) {
6824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6825 } else {
6826 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6828 }
6829 if (SWIG_IsTmpObj(res2)) {
6830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6831 } else {
6832 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6834 }
6835 if (SWIG_IsTmpObj(res3)) {
6836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6837 } else {
6838 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6840 }
6841 if (SWIG_IsTmpObj(res4)) {
6842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6843 } else {
6844 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6846 }
6847 return resultobj;
6848fail:
6849 return NULL;
6850}
6851
6852
6853SWIGINTERN PyObject *_wrap_plgdiori(PyObject *self, PyObject *args) {
6854 PyObject *resultobj = 0;
6855 PLFLT *arg1 = (PLFLT *) 0 ;
6856 PLFLT temp1 ;
6857 int res1 = SWIG_TMPOBJ ;
6858
6859 arg1 = &temp1;
6860 if (!SWIG_Python_UnpackTuple(args, "plgdiori", 0, 0, 0)) SWIG_fail;
6861 plgdiori(arg1);
6862 resultobj = SWIG_Py_Void();
6863 if (SWIG_IsTmpObj(res1)) {
6864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6865 } else {
6866 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6868 }
6869 return resultobj;
6870fail:
6871 return NULL;
6872}
6873
6874
6875SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *self, PyObject *args) {
6876 PyObject *resultobj = 0;
6877 PLFLT *arg1 = (PLFLT *) 0 ;
6878 PLFLT *arg2 = (PLFLT *) 0 ;
6879 PLFLT *arg3 = (PLFLT *) 0 ;
6880 PLFLT *arg4 = (PLFLT *) 0 ;
6881 PLFLT temp1 ;
6882 int res1 = SWIG_TMPOBJ ;
6883 PLFLT temp2 ;
6884 int res2 = SWIG_TMPOBJ ;
6885 PLFLT temp3 ;
6886 int res3 = SWIG_TMPOBJ ;
6887 PLFLT temp4 ;
6888 int res4 = SWIG_TMPOBJ ;
6889
6890 arg1 = &temp1;
6891 arg2 = &temp2;
6892 arg3 = &temp3;
6893 arg4 = &temp4;
6894 if (!SWIG_Python_UnpackTuple(args, "plgdiplt", 0, 0, 0)) SWIG_fail;
6895 plgdiplt(arg1,arg2,arg3,arg4);
6896 resultobj = SWIG_Py_Void();
6897 if (SWIG_IsTmpObj(res1)) {
6898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6899 } else {
6900 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6902 }
6903 if (SWIG_IsTmpObj(res2)) {
6904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6905 } else {
6906 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6908 }
6909 if (SWIG_IsTmpObj(res3)) {
6910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
6911 } else {
6912 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
6914 }
6915 if (SWIG_IsTmpObj(res4)) {
6916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6917 } else {
6918 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6919 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6920 }
6921 return resultobj;
6922fail:
6923 return NULL;
6924}
6925
6926
6927SWIGINTERN PyObject *_wrap_plgfam(PyObject *self, PyObject *args) {
6928 PyObject *resultobj = 0;
6929 PLINT *arg1 = (PLINT *) 0 ;
6930 PLINT *arg2 = (PLINT *) 0 ;
6931 PLINT *arg3 = (PLINT *) 0 ;
6932 PLINT temp1 ;
6933 int res1 = SWIG_TMPOBJ ;
6934 PLINT temp2 ;
6935 int res2 = SWIG_TMPOBJ ;
6936 PLINT temp3 ;
6937 int res3 = SWIG_TMPOBJ ;
6938
6939 arg1 = &temp1;
6940 arg2 = &temp2;
6941 arg3 = &temp3;
6942 if (!SWIG_Python_UnpackTuple(args, "plgfam", 0, 0, 0)) SWIG_fail;
6943 plgfam(arg1,arg2,arg3);
6944 resultobj = SWIG_Py_Void();
6945 if (SWIG_IsTmpObj(res1)) {
6946 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6947 } else {
6948 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6949 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6950 }
6951 if (SWIG_IsTmpObj(res2)) {
6952 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6953 } else {
6954 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6955 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6956 }
6957 if (SWIG_IsTmpObj(res3)) {
6958 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6959 } else {
6960 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6962 }
6963 return resultobj;
6964fail:
6965 return NULL;
6966}
6967
6968
6969SWIGINTERN PyObject *_wrap_plgfci(PyObject *self, PyObject *args) {
6970 PyObject *resultobj = 0;
6971 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
6972 PLUNICODE temp1 ;
6973 int res1 = SWIG_TMPOBJ ;
6974
6975 arg1 = &temp1;
6976 if (!SWIG_Python_UnpackTuple(args, "plgfci", 0, 0, 0)) SWIG_fail;
6977 plgfci(arg1);
6978 resultobj = SWIG_Py_Void();
6979 if (SWIG_IsTmpObj(res1)) {
6980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
6981 } else {
6982 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
6984 }
6985 return resultobj;
6986fail:
6987 return NULL;
6988}
6989
6990
6991SWIGINTERN PyObject *_wrap_plgfnam(PyObject *self, PyObject *args) {
6992 PyObject *resultobj = 0;
6993 char *arg1 = (char *) 0 ;
6994 char buff1[1000] ;
6995
6996 {
6997 arg1 = buff1;
6998 }
6999 if (!SWIG_Python_UnpackTuple(args, "plgfnam", 0, 0, 0)) SWIG_fail;
7000 plgfnam(arg1);
7001 resultobj = SWIG_Py_Void();
7002 {
7003 PyObject *o = PyString_FromString( arg1 );
7004 resultobj = t_output_helper( resultobj, o );
7005 }
7006 return resultobj;
7007fail:
7008 return NULL;
7009}
7010
7011
7012SWIGINTERN PyObject *_wrap_plgfont(PyObject *self, PyObject *args) {
7013 PyObject *resultobj = 0;
7014 PLINT *arg1 = (PLINT *) 0 ;
7015 PLINT *arg2 = (PLINT *) 0 ;
7016 PLINT *arg3 = (PLINT *) 0 ;
7017 PLINT temp1 ;
7018 int res1 = SWIG_TMPOBJ ;
7019 PLINT temp2 ;
7020 int res2 = SWIG_TMPOBJ ;
7021 PLINT temp3 ;
7022 int res3 = SWIG_TMPOBJ ;
7023
7024 arg1 = &temp1;
7025 arg2 = &temp2;
7026 arg3 = &temp3;
7027 if (!SWIG_Python_UnpackTuple(args, "plgfont", 0, 0, 0)) SWIG_fail;
7028 plgfont(arg1,arg2,arg3);
7029 resultobj = SWIG_Py_Void();
7030 if (SWIG_IsTmpObj(res1)) {
7031 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7032 } else {
7033 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7034 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7035 }
7036 if (SWIG_IsTmpObj(res2)) {
7037 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7038 } else {
7039 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7040 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7041 }
7042 if (SWIG_IsTmpObj(res3)) {
7043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7044 } else {
7045 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7047 }
7048 return resultobj;
7049fail:
7050 return NULL;
7051}
7052
7053
7054SWIGINTERN PyObject *_wrap_plglevel(PyObject *self, PyObject *args) {
7055 PyObject *resultobj = 0;
7056 PLINT *arg1 = (PLINT *) 0 ;
7057 PLINT temp1 ;
7058 int res1 = SWIG_TMPOBJ ;
7059
7060 arg1 = &temp1;
7061 if (!SWIG_Python_UnpackTuple(args, "plglevel", 0, 0, 0)) SWIG_fail;
7062 plglevel(arg1);
7063 resultobj = SWIG_Py_Void();
7064 if (SWIG_IsTmpObj(res1)) {
7065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7066 } else {
7067 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7069 }
7070 return resultobj;
7071fail:
7072 return NULL;
7073}
7074
7075
7076SWIGINTERN PyObject *_wrap_plgpage(PyObject *self, PyObject *args) {
7077 PyObject *resultobj = 0;
7078 PLFLT *arg1 = (PLFLT *) 0 ;
7079 PLFLT *arg2 = (PLFLT *) 0 ;
7080 PLINT *arg3 = (PLINT *) 0 ;
7081 PLINT *arg4 = (PLINT *) 0 ;
7082 PLINT *arg5 = (PLINT *) 0 ;
7083 PLINT *arg6 = (PLINT *) 0 ;
7084 PLFLT temp1 ;
7085 int res1 = SWIG_TMPOBJ ;
7086 PLFLT temp2 ;
7087 int res2 = SWIG_TMPOBJ ;
7088 PLINT temp3 ;
7089 int res3 = SWIG_TMPOBJ ;
7090 PLINT temp4 ;
7091 int res4 = SWIG_TMPOBJ ;
7092 PLINT temp5 ;
7093 int res5 = SWIG_TMPOBJ ;
7094 PLINT temp6 ;
7095 int res6 = SWIG_TMPOBJ ;
7096
7097 arg1 = &temp1;
7098 arg2 = &temp2;
7099 arg3 = &temp3;
7100 arg4 = &temp4;
7101 arg5 = &temp5;
7102 arg6 = &temp6;
7103 if (!SWIG_Python_UnpackTuple(args, "plgpage", 0, 0, 0)) SWIG_fail;
7104 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
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_int((*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_int, new_flags));
7123 }
7124 if (SWIG_IsTmpObj(res4)) {
7125 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*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_int, new_flags));
7129 }
7130 if (SWIG_IsTmpObj(res5)) {
7131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
7132 } else {
7133 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7135 }
7136 if (SWIG_IsTmpObj(res6)) {
7137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
7138 } else {
7139 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7140 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
7141 }
7142 return resultobj;
7143fail:
7144 return NULL;
7145}
7146
7147
7148SWIGINTERN PyObject *_wrap_plgra(PyObject *self, PyObject *args) {
7149 PyObject *resultobj = 0;
7150
7151 if (!SWIG_Python_UnpackTuple(args, "plgra", 0, 0, 0)) SWIG_fail;
7152 plgra();
7153 resultobj = SWIG_Py_Void();
7154 return resultobj;
7155fail:
7156 return NULL;
7157}
7158
7159
7160SWIGINTERN PyObject *_wrap_plgriddata(PyObject *self, PyObject *args) {
7161 PyObject *resultobj = 0;
7162 PLFLT *arg1 = (PLFLT *) 0 ;
7163 PLFLT *arg2 = (PLFLT *) 0 ;
7164 PLFLT *arg3 = (PLFLT *) 0 ;
7165 PLINT arg4 ;
7166 PLFLT *arg5 = (PLFLT *) 0 ;
7167 PLINT arg6 ;
7168 PLFLT *arg7 = (PLFLT *) 0 ;
7169 PLINT arg8 ;
7170 PLFLT **arg9 = (PLFLT **) 0 ;
7171 PLINT arg10 ;
7172 PLFLT arg11 ;
7173 PyArrayObject *tmp1 = NULL ;
7174 PyArrayObject *tmp2 = NULL ;
7175 PyArrayObject *tmp3 = NULL ;
7176 PyArrayObject *tmp5 = NULL ;
7177 PyArrayObject *tmp7 = NULL ;
7178 PyObject *array7 = NULL ;
7179 int val10 ;
7180 int ecode10 = 0 ;
7181 double val11 ;
7182 int ecode11 = 0 ;
7183 PyObject *swig_obj[7] ;
7184
7185 if (!SWIG_Python_UnpackTuple(args, "plgriddata", 7, 7, swig_obj)) SWIG_fail;
7186 {
7187 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7188 if ( tmp1 == NULL )
7189 return NULL;
7190 Alen = PyArray_DIMS( tmp1 )[0];
7191 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7192 }
7193 {
7194 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
7195 if ( tmp2 == NULL )
7196 return NULL;
7197 if ( PyArray_DIMS( tmp2 )[0] != Alen )
7198 {
7199 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7200 return NULL;
7201 }
7202 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7203 }
7204 {
7205 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
7206 if ( tmp3 == NULL )
7207 return NULL;
7208 if ( PyArray_DIMS( tmp3 )[0] != Alen )
7209 {
7210 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7211 return NULL;
7212 }
7213 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7214 arg4 = PyArray_DIMS( tmp3 )[0];
7215 }
7216 {
7217 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
7218 if ( tmp5 == NULL )
7219 return NULL;
7220 Xlen = PyArray_DIMS( tmp5 )[0];
7221 arg6 = Xlen;
7222 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7223 }
7224 {
7225 int i, size;
7226 npy_intp dims[2];
7227 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
7228 if ( tmp7 == NULL )
7229 return NULL;
7230 Ylen = PyArray_DIMS( tmp7 )[0];
7231 arg8 = Ylen;
7232 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7233 // Make created 2D array7 have dimensions from prior ArrayX in the argument
7234 // list and this ArrayY.
7235 dims[0] = Xlen;
7236 dims[1] = Ylen;
7237 array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
7238 if ( !array7 )
7239 return NULL;
7240 size = Ylen;
7241 arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
7242 for ( i = 0; i < Xlen; i++ )
7243 arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7244 }
7245 ecode10 = SWIG_AsVal_int(swig_obj[5], &val10);
7246 if (!SWIG_IsOK(ecode10)) {
7247 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7248 }
7249 arg10 = (PLINT)(val10);
7250 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
7251 if (!SWIG_IsOK(ecode11)) {
7252 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7253 }
7254 arg11 = (PLFLT)(val11);
7255 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7256 resultobj = SWIG_Py_Void();
7257 {
7258 resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
7259 }
7260 {
7261 Py_CLEAR( tmp1 );
7262 }
7263 {
7264 Py_CLEAR( tmp2 );
7265 }
7266 {
7267 Py_CLEAR( tmp3 );
7268 }
7269 {
7270 Py_CLEAR( tmp5 );
7271 }
7272 {
7273 Py_CLEAR( tmp7 );
7274 free( arg9 );
7275 }
7276 return resultobj;
7277fail:
7278 {
7279 Py_CLEAR( tmp1 );
7280 }
7281 {
7282 Py_CLEAR( tmp2 );
7283 }
7284 {
7285 Py_CLEAR( tmp3 );
7286 }
7287 {
7288 Py_CLEAR( tmp5 );
7289 }
7290 {
7291 Py_CLEAR( tmp7 );
7292 free( arg9 );
7293 }
7294 return NULL;
7295}
7296
7297
7298SWIGINTERN PyObject *_wrap_plgspa(PyObject *self, PyObject *args) {
7299 PyObject *resultobj = 0;
7300 PLFLT *arg1 = (PLFLT *) 0 ;
7301 PLFLT *arg2 = (PLFLT *) 0 ;
7302 PLFLT *arg3 = (PLFLT *) 0 ;
7303 PLFLT *arg4 = (PLFLT *) 0 ;
7304 PLFLT temp1 ;
7305 int res1 = SWIG_TMPOBJ ;
7306 PLFLT temp2 ;
7307 int res2 = SWIG_TMPOBJ ;
7308 PLFLT temp3 ;
7309 int res3 = SWIG_TMPOBJ ;
7310 PLFLT temp4 ;
7311 int res4 = SWIG_TMPOBJ ;
7312
7313 arg1 = &temp1;
7314 arg2 = &temp2;
7315 arg3 = &temp3;
7316 arg4 = &temp4;
7317 if (!SWIG_Python_UnpackTuple(args, "plgspa", 0, 0, 0)) SWIG_fail;
7318 plgspa(arg1,arg2,arg3,arg4);
7319 resultobj = SWIG_Py_Void();
7320 if (SWIG_IsTmpObj(res1)) {
7321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7322 } else {
7323 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7325 }
7326 if (SWIG_IsTmpObj(res2)) {
7327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7328 } else {
7329 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7331 }
7332 if (SWIG_IsTmpObj(res3)) {
7333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7334 } else {
7335 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7337 }
7338 if (SWIG_IsTmpObj(res4)) {
7339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7340 } else {
7341 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7343 }
7344 return resultobj;
7345fail:
7346 return NULL;
7347}
7348
7349
7350SWIGINTERN PyObject *_wrap_plgstrm(PyObject *self, PyObject *args) {
7351 PyObject *resultobj = 0;
7352 PLINT *arg1 = (PLINT *) 0 ;
7353 PLINT temp1 ;
7354 int res1 = SWIG_TMPOBJ ;
7355
7356 arg1 = &temp1;
7357 if (!SWIG_Python_UnpackTuple(args, "plgstrm", 0, 0, 0)) SWIG_fail;
7358 plgstrm(arg1);
7359 resultobj = SWIG_Py_Void();
7360 if (SWIG_IsTmpObj(res1)) {
7361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7362 } else {
7363 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7365 }
7366 return resultobj;
7367fail:
7368 return NULL;
7369}
7370
7371
7372SWIGINTERN PyObject *_wrap_plgver(PyObject *self, PyObject *args) {
7373 PyObject *resultobj = 0;
7374 char *arg1 = (char *) 0 ;
7375 char buff1[1000] ;
7376
7377 {
7378 arg1 = buff1;
7379 }
7380 if (!SWIG_Python_UnpackTuple(args, "plgver", 0, 0, 0)) SWIG_fail;
7381 plgver(arg1);
7382 resultobj = SWIG_Py_Void();
7383 {
7384 PyObject *o = PyString_FromString( arg1 );
7385 resultobj = t_output_helper( resultobj, o );
7386 }
7387 return resultobj;
7388fail:
7389 return NULL;
7390}
7391
7392
7393SWIGINTERN PyObject *_wrap_plgvpd(PyObject *self, PyObject *args) {
7394 PyObject *resultobj = 0;
7395 PLFLT *arg1 = (PLFLT *) 0 ;
7396 PLFLT *arg2 = (PLFLT *) 0 ;
7397 PLFLT *arg3 = (PLFLT *) 0 ;
7398 PLFLT *arg4 = (PLFLT *) 0 ;
7399 PLFLT temp1 ;
7400 int res1 = SWIG_TMPOBJ ;
7401 PLFLT temp2 ;
7402 int res2 = SWIG_TMPOBJ ;
7403 PLFLT temp3 ;
7404 int res3 = SWIG_TMPOBJ ;
7405 PLFLT temp4 ;
7406 int res4 = SWIG_TMPOBJ ;
7407
7408 arg1 = &temp1;
7409 arg2 = &temp2;
7410 arg3 = &temp3;
7411 arg4 = &temp4;
7412 if (!SWIG_Python_UnpackTuple(args, "plgvpd", 0, 0, 0)) SWIG_fail;
7413 plgvpd(arg1,arg2,arg3,arg4);
7414 resultobj = SWIG_Py_Void();
7415 if (SWIG_IsTmpObj(res1)) {
7416 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7417 } else {
7418 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7420 }
7421 if (SWIG_IsTmpObj(res2)) {
7422 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7423 } else {
7424 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7426 }
7427 if (SWIG_IsTmpObj(res3)) {
7428 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7429 } else {
7430 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7431 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7432 }
7433 if (SWIG_IsTmpObj(res4)) {
7434 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7435 } else {
7436 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7437 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7438 }
7439 return resultobj;
7440fail:
7441 return NULL;
7442}
7443
7444
7445SWIGINTERN PyObject *_wrap_plgvpw(PyObject *self, PyObject *args) {
7446 PyObject *resultobj = 0;
7447 PLFLT *arg1 = (PLFLT *) 0 ;
7448 PLFLT *arg2 = (PLFLT *) 0 ;
7449 PLFLT *arg3 = (PLFLT *) 0 ;
7450 PLFLT *arg4 = (PLFLT *) 0 ;
7451 PLFLT temp1 ;
7452 int res1 = SWIG_TMPOBJ ;
7453 PLFLT temp2 ;
7454 int res2 = SWIG_TMPOBJ ;
7455 PLFLT temp3 ;
7456 int res3 = SWIG_TMPOBJ ;
7457 PLFLT temp4 ;
7458 int res4 = SWIG_TMPOBJ ;
7459
7460 arg1 = &temp1;
7461 arg2 = &temp2;
7462 arg3 = &temp3;
7463 arg4 = &temp4;
7464 if (!SWIG_Python_UnpackTuple(args, "plgvpw", 0, 0, 0)) SWIG_fail;
7465 plgvpw(arg1,arg2,arg3,arg4);
7466 resultobj = SWIG_Py_Void();
7467 if (SWIG_IsTmpObj(res1)) {
7468 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7469 } else {
7470 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7472 }
7473 if (SWIG_IsTmpObj(res2)) {
7474 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7475 } else {
7476 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7477 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7478 }
7479 if (SWIG_IsTmpObj(res3)) {
7480 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7481 } else {
7482 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7483 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7484 }
7485 if (SWIG_IsTmpObj(res4)) {
7486 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7487 } else {
7488 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7489 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7490 }
7491 return resultobj;
7492fail:
7493 return NULL;
7494}
7495
7496
7497SWIGINTERN PyObject *_wrap_plgxax(PyObject *self, PyObject *args) {
7498 PyObject *resultobj = 0;
7499 PLINT *arg1 = (PLINT *) 0 ;
7500 PLINT *arg2 = (PLINT *) 0 ;
7501 PLINT temp1 ;
7502 int res1 = SWIG_TMPOBJ ;
7503 PLINT temp2 ;
7504 int res2 = SWIG_TMPOBJ ;
7505
7506 arg1 = &temp1;
7507 arg2 = &temp2;
7508 if (!SWIG_Python_UnpackTuple(args, "plgxax", 0, 0, 0)) SWIG_fail;
7509 plgxax(arg1,arg2);
7510 resultobj = SWIG_Py_Void();
7511 if (SWIG_IsTmpObj(res1)) {
7512 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7513 } else {
7514 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7516 }
7517 if (SWIG_IsTmpObj(res2)) {
7518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7519 } else {
7520 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7522 }
7523 return resultobj;
7524fail:
7525 return NULL;
7526}
7527
7528
7529SWIGINTERN PyObject *_wrap_plgyax(PyObject *self, PyObject *args) {
7530 PyObject *resultobj = 0;
7531 PLINT *arg1 = (PLINT *) 0 ;
7532 PLINT *arg2 = (PLINT *) 0 ;
7533 PLINT temp1 ;
7534 int res1 = SWIG_TMPOBJ ;
7535 PLINT temp2 ;
7536 int res2 = SWIG_TMPOBJ ;
7537
7538 arg1 = &temp1;
7539 arg2 = &temp2;
7540 if (!SWIG_Python_UnpackTuple(args, "plgyax", 0, 0, 0)) SWIG_fail;
7541 plgyax(arg1,arg2);
7542 resultobj = SWIG_Py_Void();
7543 if (SWIG_IsTmpObj(res1)) {
7544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7545 } else {
7546 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7548 }
7549 if (SWIG_IsTmpObj(res2)) {
7550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7551 } else {
7552 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7554 }
7555 return resultobj;
7556fail:
7557 return NULL;
7558}
7559
7560
7561SWIGINTERN PyObject *_wrap_plgzax(PyObject *self, PyObject *args) {
7562 PyObject *resultobj = 0;
7563 PLINT *arg1 = (PLINT *) 0 ;
7564 PLINT *arg2 = (PLINT *) 0 ;
7565 PLINT temp1 ;
7566 int res1 = SWIG_TMPOBJ ;
7567 PLINT temp2 ;
7568 int res2 = SWIG_TMPOBJ ;
7569
7570 arg1 = &temp1;
7571 arg2 = &temp2;
7572 if (!SWIG_Python_UnpackTuple(args, "plgzax", 0, 0, 0)) SWIG_fail;
7573 plgzax(arg1,arg2);
7574 resultobj = SWIG_Py_Void();
7575 if (SWIG_IsTmpObj(res1)) {
7576 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7577 } else {
7578 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7579 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7580 }
7581 if (SWIG_IsTmpObj(res2)) {
7582 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7583 } else {
7584 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7585 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7586 }
7587 return resultobj;
7588fail:
7589 return NULL;
7590}
7591
7592
7593SWIGINTERN PyObject *_wrap_plhist(PyObject *self, PyObject *args) {
7594 PyObject *resultobj = 0;
7595 PLINT arg1 ;
7596 PLFLT *arg2 = (PLFLT *) 0 ;
7597 PLFLT arg3 ;
7598 PLFLT arg4 ;
7599 PLINT arg5 ;
7600 PLINT arg6 ;
7601 PyArrayObject *tmp1 = NULL ;
7602 double val3 ;
7603 int ecode3 = 0 ;
7604 double val4 ;
7605 int ecode4 = 0 ;
7606 int val5 ;
7607 int ecode5 = 0 ;
7608 int val6 ;
7609 int ecode6 = 0 ;
7610 PyObject *swig_obj[5] ;
7611
7612 if (!SWIG_Python_UnpackTuple(args, "plhist", 5, 5, swig_obj)) SWIG_fail;
7613 {
7614 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7615 if ( tmp1 == NULL )
7616 return NULL;
7617 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7618 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7619 }
7620 ecode3 = SWIG_AsVal_double(swig_obj[1], &val3);
7621 if (!SWIG_IsOK(ecode3)) {
7622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7623 }
7624 arg3 = (PLFLT)(val3);
7625 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
7626 if (!SWIG_IsOK(ecode4)) {
7627 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7628 }
7629 arg4 = (PLFLT)(val4);
7630 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
7631 if (!SWIG_IsOK(ecode5)) {
7632 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7633 }
7634 arg5 = (PLINT)(val5);
7635 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
7636 if (!SWIG_IsOK(ecode6)) {
7637 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7638 }
7639 arg6 = (PLINT)(val6);
7640 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7641 resultobj = SWIG_Py_Void();
7642 {
7643 Py_CLEAR( tmp1 );
7644 }
7645 return resultobj;
7646fail:
7647 {
7648 Py_CLEAR( tmp1 );
7649 }
7650 return NULL;
7651}
7652
7653
7654SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *self, PyObject *args) {
7655 PyObject *resultobj = 0;
7656 PLFLT arg1 ;
7657 PLFLT arg2 ;
7658 PLFLT arg3 ;
7659 PLFLT *arg4 = (PLFLT *) 0 ;
7660 PLFLT *arg5 = (PLFLT *) 0 ;
7661 PLFLT *arg6 = (PLFLT *) 0 ;
7662 double val1 ;
7663 int ecode1 = 0 ;
7664 double val2 ;
7665 int ecode2 = 0 ;
7666 double val3 ;
7667 int ecode3 = 0 ;
7668 PLFLT temp4 ;
7669 int res4 = SWIG_TMPOBJ ;
7670 PLFLT temp5 ;
7671 int res5 = SWIG_TMPOBJ ;
7672 PLFLT temp6 ;
7673 int res6 = SWIG_TMPOBJ ;
7674 PyObject *swig_obj[3] ;
7675
7676 arg4 = &temp4;
7677 arg5 = &temp5;
7678 arg6 = &temp6;
7679 if (!SWIG_Python_UnpackTuple(args, "plhlsrgb", 3, 3, swig_obj)) SWIG_fail;
7680 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7681 if (!SWIG_IsOK(ecode1)) {
7682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7683 }
7684 arg1 = (PLFLT)(val1);
7685 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7686 if (!SWIG_IsOK(ecode2)) {
7687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7688 }
7689 arg2 = (PLFLT)(val2);
7690 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7691 if (!SWIG_IsOK(ecode3)) {
7692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7693 }
7694 arg3 = (PLFLT)(val3);
7695 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7696 resultobj = SWIG_Py_Void();
7697 if (SWIG_IsTmpObj(res4)) {
7698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7699 } else {
7700 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7702 }
7703 if (SWIG_IsTmpObj(res5)) {
7704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7705 } else {
7706 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7708 }
7709 if (SWIG_IsTmpObj(res6)) {
7710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7711 } else {
7712 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7714 }
7715 return resultobj;
7716fail:
7717 return NULL;
7718}
7719
7720
7721SWIGINTERN PyObject *_wrap_plinit(PyObject *self, PyObject *args) {
7722 PyObject *resultobj = 0;
7723
7724 if (!SWIG_Python_UnpackTuple(args, "plinit", 0, 0, 0)) SWIG_fail;
7725 plinit();
7726 resultobj = SWIG_Py_Void();
7727 return resultobj;
7728fail:
7729 return NULL;
7730}
7731
7732
7733SWIGINTERN PyObject *_wrap_pljoin(PyObject *self, PyObject *args) {
7734 PyObject *resultobj = 0;
7735 PLFLT arg1 ;
7736 PLFLT arg2 ;
7737 PLFLT arg3 ;
7738 PLFLT arg4 ;
7739 double val1 ;
7740 int ecode1 = 0 ;
7741 double val2 ;
7742 int ecode2 = 0 ;
7743 double val3 ;
7744 int ecode3 = 0 ;
7745 double val4 ;
7746 int ecode4 = 0 ;
7747 PyObject *swig_obj[4] ;
7748
7749 if (!SWIG_Python_UnpackTuple(args, "pljoin", 4, 4, swig_obj)) SWIG_fail;
7750 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7751 if (!SWIG_IsOK(ecode1)) {
7752 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
7753 }
7754 arg1 = (PLFLT)(val1);
7755 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7756 if (!SWIG_IsOK(ecode2)) {
7757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
7758 }
7759 arg2 = (PLFLT)(val2);
7760 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7761 if (!SWIG_IsOK(ecode3)) {
7762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
7763 }
7764 arg3 = (PLFLT)(val3);
7765 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
7766 if (!SWIG_IsOK(ecode4)) {
7767 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
7768 }
7769 arg4 = (PLFLT)(val4);
7770 pljoin(arg1,arg2,arg3,arg4);
7771 resultobj = SWIG_Py_Void();
7772 return resultobj;
7773fail:
7774 return NULL;
7775}
7776
7777
7778SWIGINTERN PyObject *_wrap_pllab(PyObject *self, PyObject *args) {
7779 PyObject *resultobj = 0;
7780 char *arg1 = (char *) 0 ;
7781 char *arg2 = (char *) 0 ;
7782 char *arg3 = (char *) 0 ;
7783 int res1 ;
7784 char *buf1 = 0 ;
7785 int alloc1 = 0 ;
7786 int res2 ;
7787 char *buf2 = 0 ;
7788 int alloc2 = 0 ;
7789 int res3 ;
7790 char *buf3 = 0 ;
7791 int alloc3 = 0 ;
7792 PyObject *swig_obj[3] ;
7793
7794 if (!SWIG_Python_UnpackTuple(args, "pllab", 3, 3, swig_obj)) SWIG_fail;
7795 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
7796 if (!SWIG_IsOK(res1)) {
7797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
7798 }
7799 arg1 = (char *)(buf1);
7800 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
7801 if (!SWIG_IsOK(res2)) {
7802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
7803 }
7804 arg2 = (char *)(buf2);
7805 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
7806 if (!SWIG_IsOK(res3)) {
7807 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
7808 }
7809 arg3 = (char *)(buf3);
7810 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
7811 resultobj = SWIG_Py_Void();
7812 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7813 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7814 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7815 return resultobj;
7816fail:
7817 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
7818 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7819 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
7820 return NULL;
7821}
7822
7823
7824SWIGINTERN PyObject *_wrap_pllegend(PyObject *self, PyObject *args) {
7825 PyObject *resultobj = 0;
7826 PLFLT *arg1 = (PLFLT *) 0 ;
7827 PLFLT *arg2 = (PLFLT *) 0 ;
7828 PLINT arg3 ;
7829 PLINT arg4 ;
7830 PLFLT arg5 ;
7831 PLFLT arg6 ;
7832 PLFLT arg7 ;
7833 PLINT arg8 ;
7834 PLINT arg9 ;
7835 PLINT arg10 ;
7836 PLINT arg11 ;
7837 PLINT arg12 ;
7838 PLINT arg13 ;
7839 PLINT *arg14 = (PLINT *) 0 ;
7840 PLFLT arg15 ;
7841 PLFLT arg16 ;
7842 PLFLT arg17 ;
7843 PLFLT arg18 ;
7844 PLINT *arg19 = (PLINT *) 0 ;
7845 char **arg20 = (char **) 0 ;
7846 PLINT *arg21 = (PLINT *) 0 ;
7847 PLINT *arg22 = (PLINT *) 0 ;
7848 PLFLT *arg23 = (PLFLT *) 0 ;
7849 PLFLT *arg24 = (PLFLT *) 0 ;
7850 PLINT *arg25 = (PLINT *) 0 ;
7851 PLINT *arg26 = (PLINT *) 0 ;
7852 PLFLT *arg27 = (PLFLT *) 0 ;
7853 PLINT *arg28 = (PLINT *) 0 ;
7854 PLFLT *arg29 = (PLFLT *) 0 ;
7855 PLINT *arg30 = (PLINT *) 0 ;
7856 char **arg31 = (char **) 0 ;
7857 PLFLT temp1 ;
7858 int res1 = SWIG_TMPOBJ ;
7859 PLFLT temp2 ;
7860 int res2 = SWIG_TMPOBJ ;
7861 int val3 ;
7862 int ecode3 = 0 ;
7863 int val4 ;
7864 int ecode4 = 0 ;
7865 double val5 ;
7866 int ecode5 = 0 ;
7867 double val6 ;
7868 int ecode6 = 0 ;
7869 double val7 ;
7870 int ecode7 = 0 ;
7871 int val8 ;
7872 int ecode8 = 0 ;
7873 int val9 ;
7874 int ecode9 = 0 ;
7875 int val10 ;
7876 int ecode10 = 0 ;
7877 int val11 ;
7878 int ecode11 = 0 ;
7879 int val12 ;
7880 int ecode12 = 0 ;
7881 PyArrayObject *tmp13 = NULL ;
7882 double val15 ;
7883 int ecode15 = 0 ;
7884 double val16 ;
7885 int ecode16 = 0 ;
7886 double val17 ;
7887 int ecode17 = 0 ;
7888 double val18 ;
7889 int ecode18 = 0 ;
7890 PyArrayObject *tmp19 = NULL ;
7891 PyArrayObject *tmp20 = NULL ;
7892 PyArrayObject *tmp21 = NULL ;
7893 PyArrayObject *tmp22 = NULL ;
7894 PyArrayObject *tmp23 = NULL ;
7895 PyArrayObject *tmp24 = NULL ;
7896 PyArrayObject *tmp25 = NULL ;
7897 PyArrayObject *tmp26 = NULL ;
7898 PyArrayObject *tmp27 = NULL ;
7899 PyArrayObject *tmp28 = NULL ;
7900 PyArrayObject *tmp29 = NULL ;
7901 PyArrayObject *tmp30 = NULL ;
7902 PyArrayObject *tmp31 = NULL ;
7903 PyObject *swig_obj[28] ;
7904
7905 arg1 = &temp1;
7906 arg2 = &temp2;
7907 if (!SWIG_Python_UnpackTuple(args, "pllegend", 28, 28, swig_obj)) SWIG_fail;
7908 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
7909 if (!SWIG_IsOK(ecode3)) {
7910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
7911 }
7912 arg3 = (PLINT)(val3);
7913 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
7914 if (!SWIG_IsOK(ecode4)) {
7915 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
7916 }
7917 arg4 = (PLINT)(val4);
7918 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
7919 if (!SWIG_IsOK(ecode5)) {
7920 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
7921 }
7922 arg5 = (PLFLT)(val5);
7923 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
7924 if (!SWIG_IsOK(ecode6)) {
7925 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
7926 }
7927 arg6 = (PLFLT)(val6);
7928 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
7929 if (!SWIG_IsOK(ecode7)) {
7930 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
7931 }
7932 arg7 = (PLFLT)(val7);
7933 ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
7934 if (!SWIG_IsOK(ecode8)) {
7935 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
7936 }
7937 arg8 = (PLINT)(val8);
7938 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
7939 if (!SWIG_IsOK(ecode9)) {
7940 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
7941 }
7942 arg9 = (PLINT)(val9);
7943 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
7944 if (!SWIG_IsOK(ecode10)) {
7945 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
7946 }
7947 arg10 = (PLINT)(val10);
7948 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
7949 if (!SWIG_IsOK(ecode11)) {
7950 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
7951 }
7952 arg11 = (PLINT)(val11);
7953 ecode12 = SWIG_AsVal_int(swig_obj[9], &val12);
7954 if (!SWIG_IsOK(ecode12)) {
7955 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
7956 }
7957 arg12 = (PLINT)(val12);
7958 {
7959 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[10], NPY_PLINT, 1, 1 );
7960 if ( tmp13 == NULL )
7961 return NULL;
7962 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
7963 arg14 = (PLINT *) PyArray_DATA( tmp13 );
7964 }
7965 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
7966 if (!SWIG_IsOK(ecode15)) {
7967 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
7968 }
7969 arg15 = (PLFLT)(val15);
7970 ecode16 = SWIG_AsVal_double(swig_obj[12], &val16);
7971 if (!SWIG_IsOK(ecode16)) {
7972 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
7973 }
7974 arg16 = (PLFLT)(val16);
7975 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
7976 if (!SWIG_IsOK(ecode17)) {
7977 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
7978 }
7979 arg17 = (PLFLT)(val17);
7980 ecode18 = SWIG_AsVal_double(swig_obj[14], &val18);
7981 if (!SWIG_IsOK(ecode18)) {
7982 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
7983 }
7984 arg18 = (PLFLT)(val18);
7985 {
7986 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[15], NPY_PLINT, 1, 1 );
7987 if ( tmp19 == NULL )
7988 return NULL;
7989 if ( PyArray_DIMS( tmp19 )[0] != Alen )
7990 {
7991 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7992 return NULL;
7993 }
7994 arg19 = (PLINT *) PyArray_DATA( tmp19 );
7995 }
7996 {
7997 int i;
7998 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[16], NPY_STRING, 1, 1 );
7999 if ( tmp20 == NULL )
8000 return NULL;
8001 if ( PyArray_DIMS( tmp20 )[0] != Alen )
8002 {
8003 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8004 return NULL;
8005 }
8006 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8007 for ( i = 0; i < Alen; i++ )
8008 {
8009 arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8010 if ( arg20[i] == NULL )
8011 {
8012 free( arg20 );
8013 return NULL;
8014 }
8015 }
8016 }
8017 {
8018 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8019 if ( tmp21 == NULL )
8020 return NULL;
8021 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8022 {
8023 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8024 return NULL;
8025 }
8026 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8027 }
8028 {
8029 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8030 if ( tmp22 == NULL )
8031 return NULL;
8032 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8033 {
8034 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8035 return NULL;
8036 }
8037 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8038 }
8039 {
8040 if ( swig_obj[19] != Py_None )
8041 {
8042 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 1, 1 );
8043 if ( tmp23 == NULL )
8044 return NULL;
8045 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8046 {
8047 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8048 return NULL;
8049 }
8050 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8051 }
8052 else
8053 {
8054 arg23 = NULL;
8055 }
8056 }
8057 {
8058 if ( swig_obj[20] != Py_None )
8059 {
8060 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[20], NPY_PLFLT, 1, 1 );
8061 if ( tmp24 == NULL )
8062 return NULL;
8063 if ( PyArray_DIMS( tmp24 )[0] != Alen )
8064 {
8065 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8066 return NULL;
8067 }
8068 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8069 }
8070 else
8071 {
8072 arg24 = NULL;
8073 }
8074 }
8075 {
8076 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[21], NPY_PLINT, 1, 1 );
8077 if ( tmp25 == NULL )
8078 return NULL;
8079 if ( PyArray_DIMS( tmp25 )[0] != Alen )
8080 {
8081 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8082 return NULL;
8083 }
8084 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8085 }
8086 {
8087 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[22], NPY_PLINT, 1, 1 );
8088 if ( tmp26 == NULL )
8089 return NULL;
8090 if ( PyArray_DIMS( tmp26 )[0] != Alen )
8091 {
8092 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8093 return NULL;
8094 }
8095 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8096 }
8097 {
8098 if ( swig_obj[23] != Py_None )
8099 {
8100 tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[23], NPY_PLFLT, 1, 1 );
8101 if ( tmp27 == NULL )
8102 return NULL;
8103 if ( PyArray_DIMS( tmp27 )[0] != Alen )
8104 {
8105 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8106 return NULL;
8107 }
8108 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8109 }
8110 else
8111 {
8112 arg27 = NULL;
8113 }
8114 }
8115 {
8116 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[24], NPY_PLINT, 1, 1 );
8117 if ( tmp28 == NULL )
8118 return NULL;
8119 if ( PyArray_DIMS( tmp28 )[0] != Alen )
8120 {
8121 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8122 return NULL;
8123 }
8124 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8125 }
8126 {
8127 if ( swig_obj[25] != Py_None )
8128 {
8129 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[25], NPY_PLFLT, 1, 1 );
8130 if ( tmp29 == NULL )
8131 return NULL;
8132 if ( PyArray_DIMS( tmp29 )[0] != Alen )
8133 {
8134 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8135 return NULL;
8136 }
8137 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8138 }
8139 else
8140 {
8141 arg29 = NULL;
8142 }
8143 }
8144 {
8145 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[26], NPY_PLINT, 1, 1 );
8146 if ( tmp30 == NULL )
8147 return NULL;
8148 if ( PyArray_DIMS( tmp30 )[0] != Alen )
8149 {
8150 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8151 return NULL;
8152 }
8153 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8154 }
8155 {
8156 int i;
8157 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[27], NPY_STRING, 1, 1 );
8158 if ( tmp31 == NULL )
8159 return NULL;
8160 if ( PyArray_DIMS( tmp31 )[0] != Alen )
8161 {
8162 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8163 return NULL;
8164 }
8165 arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8166 for ( i = 0; i < Alen; i++ )
8167 {
8168 arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8169 if ( arg31[i] == NULL )
8170 {
8171 free( arg31 );
8172 return NULL;
8173 }
8174 }
8175 }
8176 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);
8177 resultobj = SWIG_Py_Void();
8178 if (SWIG_IsTmpObj(res1)) {
8179 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8180 } else {
8181 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8182 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8183 }
8184 if (SWIG_IsTmpObj(res2)) {
8185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8186 } else {
8187 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8189 }
8190 {
8191 Py_CLEAR( tmp13 );
8192 }
8193 {
8194 Py_CLEAR( tmp19 );
8195 }
8196 {
8197 Py_CLEAR( tmp20 ); free( arg20 );
8198 }
8199 {
8200 Py_CLEAR( tmp21 );
8201 }
8202 {
8203 Py_CLEAR( tmp22 );
8204 }
8205 {
8206 Py_CLEAR( tmp23 );
8207 }
8208 {
8209 Py_CLEAR( tmp24 );
8210 }
8211 {
8212 Py_CLEAR( tmp25 );
8213 }
8214 {
8215 Py_CLEAR( tmp26 );
8216 }
8217 {
8218 Py_CLEAR( tmp27 );
8219 }
8220 {
8221 Py_CLEAR( tmp28 );
8222 }
8223 {
8224 Py_CLEAR( tmp29 );
8225 }
8226 {
8227 Py_CLEAR( tmp30 );
8228 }
8229 {
8230 Py_CLEAR( tmp31 ); free( arg31 );
8231 }
8232 return resultobj;
8233fail:
8234 {
8235 Py_CLEAR( tmp13 );
8236 }
8237 {
8238 Py_CLEAR( tmp19 );
8239 }
8240 {
8241 Py_CLEAR( tmp20 ); free( arg20 );
8242 }
8243 {
8244 Py_CLEAR( tmp21 );
8245 }
8246 {
8247 Py_CLEAR( tmp22 );
8248 }
8249 {
8250 Py_CLEAR( tmp23 );
8251 }
8252 {
8253 Py_CLEAR( tmp24 );
8254 }
8255 {
8256 Py_CLEAR( tmp25 );
8257 }
8258 {
8259 Py_CLEAR( tmp26 );
8260 }
8261 {
8262 Py_CLEAR( tmp27 );
8263 }
8264 {
8265 Py_CLEAR( tmp28 );
8266 }
8267 {
8268 Py_CLEAR( tmp29 );
8269 }
8270 {
8271 Py_CLEAR( tmp30 );
8272 }
8273 {
8274 Py_CLEAR( tmp31 ); free( arg31 );
8275 }
8276 return NULL;
8277}
8278
8279
8280SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *self, PyObject *args) {
8281 PyObject *resultobj = 0;
8282 PLFLT *arg1 = (PLFLT *) 0 ;
8283 PLFLT *arg2 = (PLFLT *) 0 ;
8284 PLINT arg3 ;
8285 PLINT arg4 ;
8286 PLFLT arg5 ;
8287 PLFLT arg6 ;
8288 PLFLT arg7 ;
8289 PLFLT arg8 ;
8290 PLINT arg9 ;
8291 PLINT arg10 ;
8292 PLINT arg11 ;
8293 PLFLT arg12 ;
8294 PLFLT arg13 ;
8295 PLINT arg14 ;
8296 PLFLT arg15 ;
8297 PLINT arg16 ;
8298 PLINT *arg17 = (PLINT *) 0 ;
8299 char **arg18 = (char **) 0 ;
8300 PLINT arg19 ;
8301 char **arg20 = (char **) 0 ;
8302 PLFLT *arg21 = (PLFLT *) 0 ;
8303 PLINT *arg22 = (PLINT *) 0 ;
8304 PLINT *arg23 = (PLINT *) 0 ;
8305 PLFLT **arg24 = (PLFLT **) 0 ;
8306 PLFLT temp1 ;
8307 int res1 = SWIG_TMPOBJ ;
8308 PLFLT temp2 ;
8309 int res2 = SWIG_TMPOBJ ;
8310 int val3 ;
8311 int ecode3 = 0 ;
8312 int val4 ;
8313 int ecode4 = 0 ;
8314 double val5 ;
8315 int ecode5 = 0 ;
8316 double val6 ;
8317 int ecode6 = 0 ;
8318 double val7 ;
8319 int ecode7 = 0 ;
8320 double val8 ;
8321 int ecode8 = 0 ;
8322 int val9 ;
8323 int ecode9 = 0 ;
8324 int val10 ;
8325 int ecode10 = 0 ;
8326 int val11 ;
8327 int ecode11 = 0 ;
8328 double val12 ;
8329 int ecode12 = 0 ;
8330 double val13 ;
8331 int ecode13 = 0 ;
8332 int val14 ;
8333 int ecode14 = 0 ;
8334 double val15 ;
8335 int ecode15 = 0 ;
8336 PyArrayObject *tmp16 = NULL ;
8337 PyArrayObject *tmp18 = NULL ;
8338 PyArrayObject *tmp19 = NULL ;
8339 PyArrayObject *tmp21 = NULL ;
8340 PyArrayObject *tmp22 = NULL ;
8341 PyArrayObject *tmp23 = NULL ;
8342 PyArrayObject *tmp24 = NULL ;
8343 PyObject *swig_obj[20] ;
8344
8345 arg1 = &temp1;
8346 arg2 = &temp2;
8347 if (!SWIG_Python_UnpackTuple(args, "plcolorbar", 20, 20, swig_obj)) SWIG_fail;
8348 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8349 if (!SWIG_IsOK(ecode3)) {
8350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8351 }
8352 arg3 = (PLINT)(val3);
8353 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8354 if (!SWIG_IsOK(ecode4)) {
8355 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8356 }
8357 arg4 = (PLINT)(val4);
8358 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8359 if (!SWIG_IsOK(ecode5)) {
8360 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8361 }
8362 arg5 = (PLFLT)(val5);
8363 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8364 if (!SWIG_IsOK(ecode6)) {
8365 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8366 }
8367 arg6 = (PLFLT)(val6);
8368 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8369 if (!SWIG_IsOK(ecode7)) {
8370 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8371 }
8372 arg7 = (PLFLT)(val7);
8373 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
8374 if (!SWIG_IsOK(ecode8)) {
8375 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8376 }
8377 arg8 = (PLFLT)(val8);
8378 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8379 if (!SWIG_IsOK(ecode9)) {
8380 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8381 }
8382 arg9 = (PLINT)(val9);
8383 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8384 if (!SWIG_IsOK(ecode10)) {
8385 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8386 }
8387 arg10 = (PLINT)(val10);
8388 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8389 if (!SWIG_IsOK(ecode11)) {
8390 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8391 }
8392 arg11 = (PLINT)(val11);
8393 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
8394 if (!SWIG_IsOK(ecode12)) {
8395 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8396 }
8397 arg12 = (PLFLT)(val12);
8398 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
8399 if (!SWIG_IsOK(ecode13)) {
8400 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8401 }
8402 arg13 = (PLFLT)(val13);
8403 ecode14 = SWIG_AsVal_int(swig_obj[11], &val14);
8404 if (!SWIG_IsOK(ecode14)) {
8405 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8406 }
8407 arg14 = (PLINT)(val14);
8408 ecode15 = SWIG_AsVal_double(swig_obj[12], &val15);
8409 if (!SWIG_IsOK(ecode15)) {
8410 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8411 }
8412 arg15 = (PLFLT)(val15);
8413 {
8414 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
8415 if ( tmp16 == NULL )
8416 return NULL;
8417 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8418 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8419 }
8420 {
8421 int i;
8422 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[14], NPY_STRING, 1, 1 );
8423 if ( tmp18 == NULL )
8424 return NULL;
8425 if ( PyArray_DIMS( tmp18 )[0] != Alen )
8426 {
8427 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8428 return NULL;
8429 }
8430 arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8431 for ( i = 0; i < Alen; i++ )
8432 {
8433 arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8434 if ( arg18[i] == NULL )
8435 {
8436 free( arg18 );
8437 return NULL;
8438 }
8439 }
8440 }
8441 {
8442 int i;
8443 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[15], NPY_STRING, 1, 1 );
8444 if ( tmp19 == NULL )
8445 return NULL;
8446 Alen = PyArray_DIMS( tmp19 )[0];
8447 arg19 = Alen;
8448 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8449 for ( i = 0; i < Alen; i++ )
8450 {
8451 arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8452 if ( arg20[i] == NULL )
8453 {
8454 free( arg20 );
8455 return NULL;
8456 }
8457 }
8458 }
8459 {
8460 tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[16], NPY_PLFLT, 1, 1 );
8461 if ( tmp21 == NULL )
8462 return NULL;
8463 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8464 {
8465 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8466 return NULL;
8467 }
8468 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8469 }
8470 {
8471 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8472 if ( tmp22 == NULL )
8473 return NULL;
8474 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8475 {
8476 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8477 return NULL;
8478 }
8479 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8480 }
8481 {
8482 int i;
8483 tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8484 if ( tmp23 == NULL )
8485 return NULL;
8486 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8487 {
8488 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8489 return NULL;
8490 }
8491 Xlen = PyArray_DIMS( tmp23 )[0];
8492 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8493 Ylen = -1;
8494 for ( i = 0; i < Xlen; i++ )
8495 if ( arg23[i] > Ylen )
8496 Ylen = arg23[i];
8497 }
8498 {
8499 int i, size;
8500 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 2, 2 );
8501 if ( tmp24 == NULL )
8502 return NULL;
8503 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8504 {
8505 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8506 return NULL;
8507 }
8508 size = Ylen;
8509 arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8510 for ( i = 0; i < Xlen; i++ )
8511 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8512 }
8513 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);
8514 resultobj = SWIG_Py_Void();
8515 if (SWIG_IsTmpObj(res1)) {
8516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8517 } else {
8518 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8520 }
8521 if (SWIG_IsTmpObj(res2)) {
8522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8523 } else {
8524 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8526 }
8527 {
8528 Py_CLEAR( tmp16 );
8529 }
8530 {
8531 Py_CLEAR( tmp18 ); free( arg18 );
8532 }
8533 {
8534 Py_CLEAR( tmp19 ); free( arg20 );
8535 }
8536 {
8537 Py_CLEAR( tmp21 );
8538 }
8539 {
8540 Py_CLEAR( tmp22 );
8541 }
8542 {
8543 Py_CLEAR( tmp23 );
8544 }
8545 {
8546 Py_CLEAR( tmp24 );
8547 free( arg24 );
8548 }
8549 return resultobj;
8550fail:
8551 {
8552 Py_CLEAR( tmp16 );
8553 }
8554 {
8555 Py_CLEAR( tmp18 ); free( arg18 );
8556 }
8557 {
8558 Py_CLEAR( tmp19 ); free( arg20 );
8559 }
8560 {
8561 Py_CLEAR( tmp21 );
8562 }
8563 {
8564 Py_CLEAR( tmp22 );
8565 }
8566 {
8567 Py_CLEAR( tmp23 );
8568 }
8569 {
8570 Py_CLEAR( tmp24 );
8571 free( arg24 );
8572 }
8573 return NULL;
8574}
8575
8576
8577SWIGINTERN PyObject *_wrap_pllightsource(PyObject *self, PyObject *args) {
8578 PyObject *resultobj = 0;
8579 PLFLT arg1 ;
8580 PLFLT arg2 ;
8581 PLFLT arg3 ;
8582 double val1 ;
8583 int ecode1 = 0 ;
8584 double val2 ;
8585 int ecode2 = 0 ;
8586 double val3 ;
8587 int ecode3 = 0 ;
8588 PyObject *swig_obj[3] ;
8589
8590 if (!SWIG_Python_UnpackTuple(args, "pllightsource", 3, 3, swig_obj)) SWIG_fail;
8591 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8592 if (!SWIG_IsOK(ecode1)) {
8593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8594 }
8595 arg1 = (PLFLT)(val1);
8596 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8597 if (!SWIG_IsOK(ecode2)) {
8598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8599 }
8600 arg2 = (PLFLT)(val2);
8601 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8602 if (!SWIG_IsOK(ecode3)) {
8603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8604 }
8605 arg3 = (PLFLT)(val3);
8606 pllightsource(arg1,arg2,arg3);
8607 resultobj = SWIG_Py_Void();
8608 return resultobj;
8609fail:
8610 return NULL;
8611}
8612
8613
8614SWIGINTERN PyObject *_wrap_plline(PyObject *self, PyObject *args) {
8615 PyObject *resultobj = 0;
8616 PLINT arg1 ;
8617 PLFLT *arg2 = (PLFLT *) 0 ;
8618 PLFLT *arg3 = (PLFLT *) 0 ;
8619 PyArrayObject *tmp1 = NULL ;
8620 PyArrayObject *tmp3 = NULL ;
8621 PyObject *swig_obj[2] ;
8622
8623 if (!SWIG_Python_UnpackTuple(args, "plline", 2, 2, swig_obj)) SWIG_fail;
8624 {
8625 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8626 if ( tmp1 == NULL )
8627 return NULL;
8628 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8629 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8630 }
8631 {
8632 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8633 if ( tmp3 == NULL )
8634 return NULL;
8635 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8636 {
8637 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8638 return NULL;
8639 }
8640 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8641 }
8642 plline(arg1,(double const *)arg2,(double const *)arg3);
8643 resultobj = SWIG_Py_Void();
8644 {
8645 Py_CLEAR( tmp1 );
8646 }
8647 {
8648 Py_CLEAR( tmp3 );
8649 }
8650 return resultobj;
8651fail:
8652 {
8653 Py_CLEAR( tmp1 );
8654 }
8655 {
8656 Py_CLEAR( tmp3 );
8657 }
8658 return NULL;
8659}
8660
8661
8662SWIGINTERN PyObject *_wrap_plline3(PyObject *self, PyObject *args) {
8663 PyObject *resultobj = 0;
8664 PLINT arg1 ;
8665 PLFLT *arg2 = (PLFLT *) 0 ;
8666 PLFLT *arg3 = (PLFLT *) 0 ;
8667 PLFLT *arg4 = (PLFLT *) 0 ;
8668 PyArrayObject *tmp1 = NULL ;
8669 PyArrayObject *tmp3 = NULL ;
8670 PyArrayObject *tmp4 = NULL ;
8671 PyObject *swig_obj[3] ;
8672
8673 if (!SWIG_Python_UnpackTuple(args, "plline3", 3, 3, swig_obj)) SWIG_fail;
8674 {
8675 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8676 if ( tmp1 == NULL )
8677 return NULL;
8678 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8679 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8680 }
8681 {
8682 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8683 if ( tmp3 == NULL )
8684 return NULL;
8685 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8686 {
8687 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8688 return NULL;
8689 }
8690 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8691 }
8692 {
8693 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
8694 if ( tmp4 == NULL )
8695 return NULL;
8696 if ( PyArray_DIMS( tmp4 )[0] != Alen )
8697 {
8698 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8699 return NULL;
8700 }
8701 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8702 }
8703 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8704 resultobj = SWIG_Py_Void();
8705 {
8706 Py_CLEAR( tmp1 );
8707 }
8708 {
8709 Py_CLEAR( tmp3 );
8710 }
8711 {
8712 Py_CLEAR( tmp4 );
8713 }
8714 return resultobj;
8715fail:
8716 {
8717 Py_CLEAR( tmp1 );
8718 }
8719 {
8720 Py_CLEAR( tmp3 );
8721 }
8722 {
8723 Py_CLEAR( tmp4 );
8724 }
8725 return NULL;
8726}
8727
8728
8729SWIGINTERN PyObject *_wrap_pllsty(PyObject *self, PyObject *args) {
8730 PyObject *resultobj = 0;
8731 PLINT arg1 ;
8732 int val1 ;
8733 int ecode1 = 0 ;
8734 PyObject *swig_obj[1] ;
8735
8736 if (!args) SWIG_fail;
8737 swig_obj[0] = args;
8738 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
8739 if (!SWIG_IsOK(ecode1)) {
8740 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
8741 }
8742 arg1 = (PLINT)(val1);
8743 pllsty(arg1);
8744 resultobj = SWIG_Py_Void();
8745 return resultobj;
8746fail:
8747 return NULL;
8748}
8749
8750
8751SWIGINTERN PyObject *_wrap_plmesh(PyObject *self, PyObject *args) {
8752 PyObject *resultobj = 0;
8753 PLFLT *arg1 = (PLFLT *) 0 ;
8754 PLFLT *arg2 = (PLFLT *) 0 ;
8755 PLFLT **arg3 = (PLFLT **) 0 ;
8756 PLINT arg4 ;
8757 PLINT arg5 ;
8758 PLINT arg6 ;
8759 PyArrayObject *tmp1 = NULL ;
8760 PyArrayObject *tmp2 = NULL ;
8761 PyArrayObject *tmp3 = NULL ;
8762 int val6 ;
8763 int ecode6 = 0 ;
8764 PyObject *swig_obj[4] ;
8765
8766 if (!SWIG_Python_UnpackTuple(args, "plmesh", 4, 4, swig_obj)) SWIG_fail;
8767 {
8768 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8769 if ( tmp1 == NULL )
8770 return NULL;
8771 Xlen = PyArray_DIMS( tmp1 )[0];
8772 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8773 }
8774 {
8775 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8776 if ( tmp2 == NULL )
8777 return NULL;
8778 Ylen = PyArray_DIMS( tmp2 )[0];
8779 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8780 }
8781 {
8782 int i, size;
8783 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8784 if ( tmp3 == NULL )
8785 return NULL;
8786 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8787 {
8788 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8789 return NULL;
8790 }
8791 arg4 = PyArray_DIMS( tmp3 )[0];
8792 arg5 = PyArray_DIMS( tmp3 )[1];
8793 size = arg5;
8794 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8795 for ( i = 0; i < arg4; i++ )
8796 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8797 }
8798 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8799 if (!SWIG_IsOK(ecode6)) {
8800 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
8801 }
8802 arg6 = (PLINT)(val6);
8803 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
8804 resultobj = SWIG_Py_Void();
8805 {
8806 Py_CLEAR( tmp1 );
8807 }
8808 {
8809 Py_CLEAR( tmp2 );
8810 }
8811 {
8812 Py_CLEAR( tmp3 );
8813 free( arg3 );
8814 }
8815 return resultobj;
8816fail:
8817 {
8818 Py_CLEAR( tmp1 );
8819 }
8820 {
8821 Py_CLEAR( tmp2 );
8822 }
8823 {
8824 Py_CLEAR( tmp3 );
8825 free( arg3 );
8826 }
8827 return NULL;
8828}
8829
8830
8831SWIGINTERN PyObject *_wrap_plmeshc(PyObject *self, PyObject *args) {
8832 PyObject *resultobj = 0;
8833 PLFLT *arg1 = (PLFLT *) 0 ;
8834 PLFLT *arg2 = (PLFLT *) 0 ;
8835 PLFLT **arg3 = (PLFLT **) 0 ;
8836 PLINT arg4 ;
8837 PLINT arg5 ;
8838 PLINT arg6 ;
8839 PLFLT *arg7 = (PLFLT *) 0 ;
8840 PLINT arg8 ;
8841 PyArrayObject *tmp1 = NULL ;
8842 PyArrayObject *tmp2 = NULL ;
8843 PyArrayObject *tmp3 = NULL ;
8844 int val6 ;
8845 int ecode6 = 0 ;
8846 PyArrayObject *tmp7 = NULL ;
8847 PyObject *swig_obj[5] ;
8848
8849 if (!SWIG_Python_UnpackTuple(args, "plmeshc", 5, 5, swig_obj)) SWIG_fail;
8850 {
8851 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8852 if ( tmp1 == NULL )
8853 return NULL;
8854 Xlen = PyArray_DIMS( tmp1 )[0];
8855 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
8856 }
8857 {
8858 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8859 if ( tmp2 == NULL )
8860 return NULL;
8861 Ylen = PyArray_DIMS( tmp2 )[0];
8862 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
8863 }
8864 {
8865 int i, size;
8866 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
8867 if ( tmp3 == NULL )
8868 return NULL;
8869 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
8870 {
8871 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8872 return NULL;
8873 }
8874 arg4 = PyArray_DIMS( tmp3 )[0];
8875 arg5 = PyArray_DIMS( tmp3 )[1];
8876 size = arg5;
8877 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
8878 for ( i = 0; i < arg4; i++ )
8879 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
8880 }
8881 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
8882 if (!SWIG_IsOK(ecode6)) {
8883 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
8884 }
8885 arg6 = (PLINT)(val6);
8886 {
8887 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
8888 if ( tmp7 == NULL )
8889 return NULL;
8890 arg8 = PyArray_DIMS( tmp7 )[0];
8891 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
8892 }
8893 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
8894 resultobj = SWIG_Py_Void();
8895 {
8896 Py_CLEAR( tmp1 );
8897 }
8898 {
8899 Py_CLEAR( tmp2 );
8900 }
8901 {
8902 Py_CLEAR( tmp3 );
8903 free( arg3 );
8904 }
8905 {
8906 Py_CLEAR( tmp7 );
8907 }
8908 return resultobj;
8909fail:
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 NULL;
8924}
8925
8926
8927SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *self, PyObject *args) {
8928 PyObject *resultobj = 0;
8929 PLINT *arg1 = (PLINT *) 0 ;
8930 PLINT temp1 ;
8931 int res1 = SWIG_TMPOBJ ;
8932
8933 arg1 = &temp1;
8934 if (!SWIG_Python_UnpackTuple(args, "plmkstrm", 0, 0, 0)) SWIG_fail;
8935 plmkstrm(arg1);
8936 resultobj = SWIG_Py_Void();
8937 if (SWIG_IsTmpObj(res1)) {
8938 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
8939 } else {
8940 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8942 }
8943 return resultobj;
8944fail:
8945 return NULL;
8946}
8947
8948
8949SWIGINTERN PyObject *_wrap_plmtex(PyObject *self, PyObject *args) {
8950 PyObject *resultobj = 0;
8951 char *arg1 = (char *) 0 ;
8952 PLFLT arg2 ;
8953 PLFLT arg3 ;
8954 PLFLT arg4 ;
8955 char *arg5 = (char *) 0 ;
8956 int res1 ;
8957 char *buf1 = 0 ;
8958 int alloc1 = 0 ;
8959 double val2 ;
8960 int ecode2 = 0 ;
8961 double val3 ;
8962 int ecode3 = 0 ;
8963 double val4 ;
8964 int ecode4 = 0 ;
8965 int res5 ;
8966 char *buf5 = 0 ;
8967 int alloc5 = 0 ;
8968 PyObject *swig_obj[5] ;
8969
8970 if (!SWIG_Python_UnpackTuple(args, "plmtex", 5, 5, swig_obj)) SWIG_fail;
8971 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8972 if (!SWIG_IsOK(res1)) {
8973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
8974 }
8975 arg1 = (char *)(buf1);
8976 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8977 if (!SWIG_IsOK(ecode2)) {
8978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
8979 }
8980 arg2 = (PLFLT)(val2);
8981 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8982 if (!SWIG_IsOK(ecode3)) {
8983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
8984 }
8985 arg3 = (PLFLT)(val3);
8986 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8987 if (!SWIG_IsOK(ecode4)) {
8988 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
8989 }
8990 arg4 = (PLFLT)(val4);
8991 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
8992 if (!SWIG_IsOK(res5)) {
8993 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
8994 }
8995 arg5 = (char *)(buf5);
8996 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
8997 resultobj = SWIG_Py_Void();
8998 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8999 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9000 return resultobj;
9001fail:
9002 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9003 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9004 return NULL;
9005}
9006
9007
9008SWIGINTERN PyObject *_wrap_plmtex3(PyObject *self, PyObject *args) {
9009 PyObject *resultobj = 0;
9010 char *arg1 = (char *) 0 ;
9011 PLFLT arg2 ;
9012 PLFLT arg3 ;
9013 PLFLT arg4 ;
9014 char *arg5 = (char *) 0 ;
9015 int res1 ;
9016 char *buf1 = 0 ;
9017 int alloc1 = 0 ;
9018 double val2 ;
9019 int ecode2 = 0 ;
9020 double val3 ;
9021 int ecode3 = 0 ;
9022 double val4 ;
9023 int ecode4 = 0 ;
9024 int res5 ;
9025 char *buf5 = 0 ;
9026 int alloc5 = 0 ;
9027 PyObject *swig_obj[5] ;
9028
9029 if (!SWIG_Python_UnpackTuple(args, "plmtex3", 5, 5, swig_obj)) SWIG_fail;
9030 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9031 if (!SWIG_IsOK(res1)) {
9032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9033 }
9034 arg1 = (char *)(buf1);
9035 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9036 if (!SWIG_IsOK(ecode2)) {
9037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9038 }
9039 arg2 = (PLFLT)(val2);
9040 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9041 if (!SWIG_IsOK(ecode3)) {
9042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9043 }
9044 arg3 = (PLFLT)(val3);
9045 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9046 if (!SWIG_IsOK(ecode4)) {
9047 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9048 }
9049 arg4 = (PLFLT)(val4);
9050 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9051 if (!SWIG_IsOK(res5)) {
9052 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9053 }
9054 arg5 = (char *)(buf5);
9055 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9056 resultobj = SWIG_Py_Void();
9057 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9058 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9059 return resultobj;
9060fail:
9061 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9062 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9063 return NULL;
9064}
9065
9066
9067SWIGINTERN PyObject *_wrap_plot3d(PyObject *self, PyObject *args) {
9068 PyObject *resultobj = 0;
9069 PLFLT *arg1 = (PLFLT *) 0 ;
9070 PLFLT *arg2 = (PLFLT *) 0 ;
9071 PLFLT **arg3 = (PLFLT **) 0 ;
9072 PLINT arg4 ;
9073 PLINT arg5 ;
9074 PLINT arg6 ;
9075 PLBOOL arg7 ;
9076 PyArrayObject *tmp1 = NULL ;
9077 PyArrayObject *tmp2 = NULL ;
9078 PyArrayObject *tmp3 = NULL ;
9079 int val6 ;
9080 int ecode6 = 0 ;
9081 int val7 ;
9082 int ecode7 = 0 ;
9083 PyObject *swig_obj[5] ;
9084
9085 if (!SWIG_Python_UnpackTuple(args, "plot3d", 5, 5, swig_obj)) SWIG_fail;
9086 {
9087 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9088 if ( tmp1 == NULL )
9089 return NULL;
9090 Xlen = PyArray_DIMS( tmp1 )[0];
9091 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9092 }
9093 {
9094 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9095 if ( tmp2 == NULL )
9096 return NULL;
9097 Ylen = PyArray_DIMS( tmp2 )[0];
9098 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9099 }
9100 {
9101 int i, size;
9102 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9103 if ( tmp3 == NULL )
9104 return NULL;
9105 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9106 {
9107 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9108 return NULL;
9109 }
9110 arg4 = PyArray_DIMS( tmp3 )[0];
9111 arg5 = PyArray_DIMS( tmp3 )[1];
9112 size = arg5;
9113 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9114 for ( i = 0; i < arg4; i++ )
9115 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9116 }
9117 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9118 if (!SWIG_IsOK(ecode6)) {
9119 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9120 }
9121 arg6 = (PLINT)(val6);
9122 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
9123 if (!SWIG_IsOK(ecode7)) {
9124 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9125 }
9126 arg7 = (PLBOOL)(val7);
9127 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9128 resultobj = SWIG_Py_Void();
9129 {
9130 Py_CLEAR( tmp1 );
9131 }
9132 {
9133 Py_CLEAR( tmp2 );
9134 }
9135 {
9136 Py_CLEAR( tmp3 );
9137 free( arg3 );
9138 }
9139 return resultobj;
9140fail:
9141 {
9142 Py_CLEAR( tmp1 );
9143 }
9144 {
9145 Py_CLEAR( tmp2 );
9146 }
9147 {
9148 Py_CLEAR( tmp3 );
9149 free( arg3 );
9150 }
9151 return NULL;
9152}
9153
9154
9155SWIGINTERN PyObject *_wrap_plot3dc(PyObject *self, PyObject *args) {
9156 PyObject *resultobj = 0;
9157 PLFLT *arg1 = (PLFLT *) 0 ;
9158 PLFLT *arg2 = (PLFLT *) 0 ;
9159 PLFLT **arg3 = (PLFLT **) 0 ;
9160 PLINT arg4 ;
9161 PLINT arg5 ;
9162 PLINT arg6 ;
9163 PLFLT *arg7 = (PLFLT *) 0 ;
9164 PLINT arg8 ;
9165 PyArrayObject *tmp1 = NULL ;
9166 PyArrayObject *tmp2 = NULL ;
9167 PyArrayObject *tmp3 = NULL ;
9168 int val6 ;
9169 int ecode6 = 0 ;
9170 PyArrayObject *tmp7 = NULL ;
9171 PyObject *swig_obj[5] ;
9172
9173 if (!SWIG_Python_UnpackTuple(args, "plot3dc", 5, 5, swig_obj)) SWIG_fail;
9174 {
9175 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9176 if ( tmp1 == NULL )
9177 return NULL;
9178 Xlen = PyArray_DIMS( tmp1 )[0];
9179 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9180 }
9181 {
9182 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9183 if ( tmp2 == NULL )
9184 return NULL;
9185 Ylen = PyArray_DIMS( tmp2 )[0];
9186 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9187 }
9188 {
9189 int i, size;
9190 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9191 if ( tmp3 == NULL )
9192 return NULL;
9193 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9194 {
9195 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9196 return NULL;
9197 }
9198 arg4 = PyArray_DIMS( tmp3 )[0];
9199 arg5 = PyArray_DIMS( tmp3 )[1];
9200 size = arg5;
9201 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9202 for ( i = 0; i < arg4; i++ )
9203 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9204 }
9205 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9206 if (!SWIG_IsOK(ecode6)) {
9207 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9208 }
9209 arg6 = (PLINT)(val6);
9210 {
9211 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9212 if ( tmp7 == NULL )
9213 return NULL;
9214 arg8 = PyArray_DIMS( tmp7 )[0];
9215 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9216 }
9217 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9218 resultobj = SWIG_Py_Void();
9219 {
9220 Py_CLEAR( tmp1 );
9221 }
9222 {
9223 Py_CLEAR( tmp2 );
9224 }
9225 {
9226 Py_CLEAR( tmp3 );
9227 free( arg3 );
9228 }
9229 {
9230 Py_CLEAR( tmp7 );
9231 }
9232 return resultobj;
9233fail:
9234 {
9235 Py_CLEAR( tmp1 );
9236 }
9237 {
9238 Py_CLEAR( tmp2 );
9239 }
9240 {
9241 Py_CLEAR( tmp3 );
9242 free( arg3 );
9243 }
9244 {
9245 Py_CLEAR( tmp7 );
9246 }
9247 return NULL;
9248}
9249
9250
9251SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *self, PyObject *args) {
9252 PyObject *resultobj = 0;
9253 PLFLT *arg1 = (PLFLT *) 0 ;
9254 PLFLT *arg2 = (PLFLT *) 0 ;
9255 PLFLT **arg3 = (PLFLT **) 0 ;
9256 PLINT arg4 ;
9257 PLINT arg5 ;
9258 PLINT arg6 ;
9259 PLFLT *arg7 = (PLFLT *) 0 ;
9260 PLINT arg8 ;
9261 PLINT arg9 ;
9262 PLINT arg10 ;
9263 PLINT *arg11 = (PLINT *) 0 ;
9264 PLINT *arg12 = (PLINT *) 0 ;
9265 PyArrayObject *tmp1 = NULL ;
9266 PyArrayObject *tmp2 = NULL ;
9267 PyArrayObject *tmp3 = NULL ;
9268 int val6 ;
9269 int ecode6 = 0 ;
9270 PyArrayObject *tmp7 = NULL ;
9271 int val9 ;
9272 int ecode9 = 0 ;
9273 PyArrayObject *tmp10 = NULL ;
9274 PyArrayObject *tmp12 = NULL ;
9275 PyObject *swig_obj[8] ;
9276
9277 if (!SWIG_Python_UnpackTuple(args, "plot3dcl", 8, 8, swig_obj)) SWIG_fail;
9278 {
9279 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9280 if ( tmp1 == NULL )
9281 return NULL;
9282 Xlen = PyArray_DIMS( tmp1 )[0];
9283 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9284 }
9285 {
9286 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9287 if ( tmp2 == NULL )
9288 return NULL;
9289 Ylen = PyArray_DIMS( tmp2 )[0];
9290 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9291 }
9292 {
9293 int i, size;
9294 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9295 if ( tmp3 == NULL )
9296 return NULL;
9297 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9298 {
9299 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9300 return NULL;
9301 }
9302 arg4 = PyArray_DIMS( tmp3 )[0];
9303 arg5 = PyArray_DIMS( tmp3 )[1];
9304 size = arg5;
9305 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9306 for ( i = 0; i < arg4; i++ )
9307 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9308 }
9309 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9310 if (!SWIG_IsOK(ecode6)) {
9311 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9312 }
9313 arg6 = (PLINT)(val6);
9314 {
9315 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9316 if ( tmp7 == NULL )
9317 return NULL;
9318 arg8 = PyArray_DIMS( tmp7 )[0];
9319 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9320 }
9321 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9322 if (!SWIG_IsOK(ecode9)) {
9323 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9324 }
9325 arg9 = (PLINT)(val9);
9326 {
9327 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9328 if ( tmp10 == NULL )
9329 return NULL;
9330 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9331 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9332 }
9333 {
9334 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9335 if ( tmp12 == NULL )
9336 return NULL;
9337 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9338 {
9339 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9340 return NULL;
9341 }
9342 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9343 }
9344 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);
9345 resultobj = SWIG_Py_Void();
9346 {
9347 Py_CLEAR( tmp1 );
9348 }
9349 {
9350 Py_CLEAR( tmp2 );
9351 }
9352 {
9353 Py_CLEAR( tmp3 );
9354 free( arg3 );
9355 }
9356 {
9357 Py_CLEAR( tmp7 );
9358 }
9359 {
9360 Py_CLEAR( tmp10 );
9361 }
9362 {
9363 Py_CLEAR( tmp12 );
9364 }
9365 return resultobj;
9366fail:
9367 {
9368 Py_CLEAR( tmp1 );
9369 }
9370 {
9371 Py_CLEAR( tmp2 );
9372 }
9373 {
9374 Py_CLEAR( tmp3 );
9375 free( arg3 );
9376 }
9377 {
9378 Py_CLEAR( tmp7 );
9379 }
9380 {
9381 Py_CLEAR( tmp10 );
9382 }
9383 {
9384 Py_CLEAR( tmp12 );
9385 }
9386 return NULL;
9387}
9388
9389
9390SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *self, PyObject *args) {
9391 PyObject *resultobj = 0;
9392 PLFLT *arg1 = (PLFLT *) 0 ;
9393 PLFLT *arg2 = (PLFLT *) 0 ;
9394 PLFLT **arg3 = (PLFLT **) 0 ;
9395 PLINT arg4 ;
9396 PLINT arg5 ;
9397 PLINT arg6 ;
9398 PLFLT *arg7 = (PLFLT *) 0 ;
9399 PLINT arg8 ;
9400 PyArrayObject *tmp1 = NULL ;
9401 PyArrayObject *tmp2 = NULL ;
9402 PyArrayObject *tmp3 = NULL ;
9403 int val6 ;
9404 int ecode6 = 0 ;
9405 PyArrayObject *tmp7 = NULL ;
9406 PyObject *swig_obj[5] ;
9407
9408 if (!SWIG_Python_UnpackTuple(args, "plsurf3d", 5, 5, swig_obj)) SWIG_fail;
9409 {
9410 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9411 if ( tmp1 == NULL )
9412 return NULL;
9413 Xlen = PyArray_DIMS( tmp1 )[0];
9414 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9415 }
9416 {
9417 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9418 if ( tmp2 == NULL )
9419 return NULL;
9420 Ylen = PyArray_DIMS( tmp2 )[0];
9421 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9422 }
9423 {
9424 int i, size;
9425 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9426 if ( tmp3 == NULL )
9427 return NULL;
9428 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9429 {
9430 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9431 return NULL;
9432 }
9433 arg4 = PyArray_DIMS( tmp3 )[0];
9434 arg5 = PyArray_DIMS( tmp3 )[1];
9435 size = arg5;
9436 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9437 for ( i = 0; i < arg4; i++ )
9438 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9439 }
9440 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9441 if (!SWIG_IsOK(ecode6)) {
9442 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9443 }
9444 arg6 = (PLINT)(val6);
9445 {
9446 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9447 if ( tmp7 == NULL )
9448 return NULL;
9449 arg8 = PyArray_DIMS( tmp7 )[0];
9450 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9451 }
9452 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9453 resultobj = SWIG_Py_Void();
9454 {
9455 Py_CLEAR( tmp1 );
9456 }
9457 {
9458 Py_CLEAR( tmp2 );
9459 }
9460 {
9461 Py_CLEAR( tmp3 );
9462 free( arg3 );
9463 }
9464 {
9465 Py_CLEAR( tmp7 );
9466 }
9467 return resultobj;
9468fail:
9469 {
9470 Py_CLEAR( tmp1 );
9471 }
9472 {
9473 Py_CLEAR( tmp2 );
9474 }
9475 {
9476 Py_CLEAR( tmp3 );
9477 free( arg3 );
9478 }
9479 {
9480 Py_CLEAR( tmp7 );
9481 }
9482 return NULL;
9483}
9484
9485
9486SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *self, PyObject *args) {
9487 PyObject *resultobj = 0;
9488 PLFLT *arg1 = (PLFLT *) 0 ;
9489 PLFLT *arg2 = (PLFLT *) 0 ;
9490 PLFLT **arg3 = (PLFLT **) 0 ;
9491 PLINT arg4 ;
9492 PLINT arg5 ;
9493 PLINT arg6 ;
9494 PLFLT *arg7 = (PLFLT *) 0 ;
9495 PLINT arg8 ;
9496 PLINT arg9 ;
9497 PLINT arg10 ;
9498 PLINT *arg11 = (PLINT *) 0 ;
9499 PLINT *arg12 = (PLINT *) 0 ;
9500 PyArrayObject *tmp1 = NULL ;
9501 PyArrayObject *tmp2 = NULL ;
9502 PyArrayObject *tmp3 = NULL ;
9503 int val6 ;
9504 int ecode6 = 0 ;
9505 PyArrayObject *tmp7 = NULL ;
9506 int val9 ;
9507 int ecode9 = 0 ;
9508 PyArrayObject *tmp10 = NULL ;
9509 PyArrayObject *tmp12 = NULL ;
9510 PyObject *swig_obj[8] ;
9511
9512 if (!SWIG_Python_UnpackTuple(args, "plsurf3dl", 8, 8, swig_obj)) SWIG_fail;
9513 {
9514 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9515 if ( tmp1 == NULL )
9516 return NULL;
9517 Xlen = PyArray_DIMS( tmp1 )[0];
9518 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9519 }
9520 {
9521 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9522 if ( tmp2 == NULL )
9523 return NULL;
9524 Ylen = PyArray_DIMS( tmp2 )[0];
9525 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9526 }
9527 {
9528 int i, size;
9529 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9530 if ( tmp3 == NULL )
9531 return NULL;
9532 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9533 {
9534 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9535 return NULL;
9536 }
9537 arg4 = PyArray_DIMS( tmp3 )[0];
9538 arg5 = PyArray_DIMS( tmp3 )[1];
9539 size = arg5;
9540 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9541 for ( i = 0; i < arg4; i++ )
9542 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9543 }
9544 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9545 if (!SWIG_IsOK(ecode6)) {
9546 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9547 }
9548 arg6 = (PLINT)(val6);
9549 {
9550 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9551 if ( tmp7 == NULL )
9552 return NULL;
9553 arg8 = PyArray_DIMS( tmp7 )[0];
9554 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9555 }
9556 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9557 if (!SWIG_IsOK(ecode9)) {
9558 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9559 }
9560 arg9 = (PLINT)(val9);
9561 {
9562 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9563 if ( tmp10 == NULL )
9564 return NULL;
9565 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9566 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9567 }
9568 {
9569 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9570 if ( tmp12 == NULL )
9571 return NULL;
9572 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9573 {
9574 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9575 return NULL;
9576 }
9577 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9578 }
9579 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);
9580 resultobj = SWIG_Py_Void();
9581 {
9582 Py_CLEAR( tmp1 );
9583 }
9584 {
9585 Py_CLEAR( tmp2 );
9586 }
9587 {
9588 Py_CLEAR( tmp3 );
9589 free( arg3 );
9590 }
9591 {
9592 Py_CLEAR( tmp7 );
9593 }
9594 {
9595 Py_CLEAR( tmp10 );
9596 }
9597 {
9598 Py_CLEAR( tmp12 );
9599 }
9600 return resultobj;
9601fail:
9602 {
9603 Py_CLEAR( tmp1 );
9604 }
9605 {
9606 Py_CLEAR( tmp2 );
9607 }
9608 {
9609 Py_CLEAR( tmp3 );
9610 free( arg3 );
9611 }
9612 {
9613 Py_CLEAR( tmp7 );
9614 }
9615 {
9616 Py_CLEAR( tmp10 );
9617 }
9618 {
9619 Py_CLEAR( tmp12 );
9620 }
9621 return NULL;
9622}
9623
9624
9625SWIGINTERN PyObject *_wrap_plparseopts(PyObject *self, PyObject *args) {
9626 PyObject *resultobj = 0;
9627 int *arg1 = (int *) 0 ;
9628 char **arg2 = (char **) 0 ;
9629 PLINT arg3 ;
9630 int tmp1 ;
9631 int val3 ;
9632 int ecode3 = 0 ;
9633 PyObject *swig_obj[2] ;
9634 PLINT result;
9635
9636 if (!SWIG_Python_UnpackTuple(args, "plparseopts", 2, 2, swig_obj)) SWIG_fail;
9637 {
9638 int i;
9639 PyObject *unicode_string;
9640
9641 if ( !PyList_Check( swig_obj[0] ) )
9642 {
9643 PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9644 return NULL;
9645 }
9646 tmp1 = PyList_Size( swig_obj[0] );
9647 arg1 = &tmp1;
9648 arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9649 for ( i = 0; i < tmp1; i++ )
9650 {
9651 PyObject *s = PyList_GetItem( swig_obj[0], i );
9652 if ( PyString_Check( s ) )
9653 {
9654 arg2[i] = PyString_AsString( s );
9655 }
9656 else if ( PyUnicode_Check( s ) )
9657 {
9658 // unicode_string is never freed? memory leak here?
9659 unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9660 arg2[i] = PyBytes_AS_STRING( unicode_string );
9661 }
9662 else
9663 {
9664 free( arg2 );
9665 PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9666 return NULL;
9667 }
9668 }
9669 arg2[i] = 0;
9670 }
9671 ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
9672 if (!SWIG_IsOK(ecode3)) {
9673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9674 }
9675 arg3 = (PLINT)(val3);
9676 result = (PLINT)plparseopts(arg1,arg2,arg3);
9677 resultobj = SWIG_From_int((int)(result));
9678 {
9679 if ( arg2 )
9680 free( arg2 );
9681 }
9682 return resultobj;
9683fail:
9684 {
9685 if ( arg2 )
9686 free( arg2 );
9687 }
9688 return NULL;
9689}
9690
9691
9692SWIGINTERN PyObject *_wrap_plpat(PyObject *self, PyObject *args) {
9693 PyObject *resultobj = 0;
9694 PLINT arg1 ;
9695 PLINT *arg2 = (PLINT *) 0 ;
9696 PLINT *arg3 = (PLINT *) 0 ;
9697 PyArrayObject *tmp1 = NULL ;
9698 PyArrayObject *tmp3 = NULL ;
9699 PyObject *swig_obj[2] ;
9700
9701 if (!SWIG_Python_UnpackTuple(args, "plpat", 2, 2, swig_obj)) SWIG_fail;
9702 {
9703 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
9704 if ( tmp1 == NULL )
9705 return NULL;
9706 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9707 arg2 = (PLINT *) PyArray_DATA( tmp1 );
9708 }
9709 {
9710 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
9711 if ( tmp3 == NULL )
9712 return NULL;
9713 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9714 {
9715 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9716 return NULL;
9717 }
9718 arg3 = (PLINT *) PyArray_DATA( tmp3 );
9719 }
9720 plpat(arg1,(int const *)arg2,(int const *)arg3);
9721 resultobj = SWIG_Py_Void();
9722 {
9723 Py_CLEAR( tmp1 );
9724 }
9725 {
9726 Py_CLEAR( tmp3 );
9727 }
9728 return resultobj;
9729fail:
9730 {
9731 Py_CLEAR( tmp1 );
9732 }
9733 {
9734 Py_CLEAR( tmp3 );
9735 }
9736 return NULL;
9737}
9738
9739
9740SWIGINTERN PyObject *_wrap_plpath(PyObject *self, PyObject *args) {
9741 PyObject *resultobj = 0;
9742 PLINT arg1 ;
9743 PLFLT arg2 ;
9744 PLFLT arg3 ;
9745 PLFLT arg4 ;
9746 PLFLT arg5 ;
9747 int val1 ;
9748 int ecode1 = 0 ;
9749 double val2 ;
9750 int ecode2 = 0 ;
9751 double val3 ;
9752 int ecode3 = 0 ;
9753 double val4 ;
9754 int ecode4 = 0 ;
9755 double val5 ;
9756 int ecode5 = 0 ;
9757 PyObject *swig_obj[5] ;
9758
9759 if (!SWIG_Python_UnpackTuple(args, "plpath", 5, 5, swig_obj)) SWIG_fail;
9760 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9761 if (!SWIG_IsOK(ecode1)) {
9762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
9763 }
9764 arg1 = (PLINT)(val1);
9765 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9766 if (!SWIG_IsOK(ecode2)) {
9767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
9768 }
9769 arg2 = (PLFLT)(val2);
9770 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9771 if (!SWIG_IsOK(ecode3)) {
9772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
9773 }
9774 arg3 = (PLFLT)(val3);
9775 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9776 if (!SWIG_IsOK(ecode4)) {
9777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
9778 }
9779 arg4 = (PLFLT)(val4);
9780 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
9781 if (!SWIG_IsOK(ecode5)) {
9782 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
9783 }
9784 arg5 = (PLFLT)(val5);
9785 plpath(arg1,arg2,arg3,arg4,arg5);
9786 resultobj = SWIG_Py_Void();
9787 return resultobj;
9788fail:
9789 return NULL;
9790}
9791
9792
9793SWIGINTERN PyObject *_wrap_plpoin(PyObject *self, PyObject *args) {
9794 PyObject *resultobj = 0;
9795 PLINT arg1 ;
9796 PLFLT *arg2 = (PLFLT *) 0 ;
9797 PLFLT *arg3 = (PLFLT *) 0 ;
9798 PLINT arg4 ;
9799 PyArrayObject *tmp1 = NULL ;
9800 PyArrayObject *tmp3 = NULL ;
9801 int val4 ;
9802 int ecode4 = 0 ;
9803 PyObject *swig_obj[3] ;
9804
9805 if (!SWIG_Python_UnpackTuple(args, "plpoin", 3, 3, swig_obj)) SWIG_fail;
9806 {
9807 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9808 if ( tmp1 == NULL )
9809 return NULL;
9810 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9811 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9812 }
9813 {
9814 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9815 if ( tmp3 == NULL )
9816 return NULL;
9817 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9818 {
9819 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9820 return NULL;
9821 }
9822 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9823 }
9824 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
9825 if (!SWIG_IsOK(ecode4)) {
9826 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
9827 }
9828 arg4 = (PLINT)(val4);
9829 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
9830 resultobj = SWIG_Py_Void();
9831 {
9832 Py_CLEAR( tmp1 );
9833 }
9834 {
9835 Py_CLEAR( tmp3 );
9836 }
9837 return resultobj;
9838fail:
9839 {
9840 Py_CLEAR( tmp1 );
9841 }
9842 {
9843 Py_CLEAR( tmp3 );
9844 }
9845 return NULL;
9846}
9847
9848
9849SWIGINTERN PyObject *_wrap_plpoin3(PyObject *self, PyObject *args) {
9850 PyObject *resultobj = 0;
9851 PLINT arg1 ;
9852 PLFLT *arg2 = (PLFLT *) 0 ;
9853 PLFLT *arg3 = (PLFLT *) 0 ;
9854 PLFLT *arg4 = (PLFLT *) 0 ;
9855 PLINT arg5 ;
9856 PyArrayObject *tmp1 = NULL ;
9857 PyArrayObject *tmp3 = NULL ;
9858 PyArrayObject *tmp4 = NULL ;
9859 int val5 ;
9860 int ecode5 = 0 ;
9861 PyObject *swig_obj[4] ;
9862
9863 if (!SWIG_Python_UnpackTuple(args, "plpoin3", 4, 4, swig_obj)) SWIG_fail;
9864 {
9865 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9866 if ( tmp1 == NULL )
9867 return NULL;
9868 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9869 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9870 }
9871 {
9872 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9873 if ( tmp3 == NULL )
9874 return NULL;
9875 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9876 {
9877 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9878 return NULL;
9879 }
9880 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9881 }
9882 {
9883 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9884 if ( tmp4 == NULL )
9885 return NULL;
9886 if ( PyArray_DIMS( tmp4 )[0] != Alen )
9887 {
9888 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9889 return NULL;
9890 }
9891 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9892 }
9893 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
9894 if (!SWIG_IsOK(ecode5)) {
9895 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
9896 }
9897 arg5 = (PLINT)(val5);
9898 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
9899 resultobj = SWIG_Py_Void();
9900 {
9901 Py_CLEAR( tmp1 );
9902 }
9903 {
9904 Py_CLEAR( tmp3 );
9905 }
9906 {
9907 Py_CLEAR( tmp4 );
9908 }
9909 return resultobj;
9910fail:
9911 {
9912 Py_CLEAR( tmp1 );
9913 }
9914 {
9915 Py_CLEAR( tmp3 );
9916 }
9917 {
9918 Py_CLEAR( tmp4 );
9919 }
9920 return NULL;
9921}
9922
9923
9924SWIGINTERN PyObject *_wrap_plpoly3(PyObject *self, PyObject *args) {
9925 PyObject *resultobj = 0;
9926 PLINT arg1 ;
9927 PLFLT *arg2 = (PLFLT *) 0 ;
9928 PLFLT *arg3 = (PLFLT *) 0 ;
9929 PLFLT *arg4 = (PLFLT *) 0 ;
9930 PLBOOL *arg5 = (PLBOOL *) 0 ;
9931 PLBOOL arg6 ;
9932 PyArrayObject *tmp1 = NULL ;
9933 PyArrayObject *tmp3 = NULL ;
9934 PyArrayObject *tmp4 = NULL ;
9935 PyArrayObject *tmp5 = NULL ;
9936 int val6 ;
9937 int ecode6 = 0 ;
9938 PyObject *swig_obj[5] ;
9939
9940 if (!SWIG_Python_UnpackTuple(args, "plpoly3", 5, 5, swig_obj)) SWIG_fail;
9941 {
9942 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9943 if ( tmp1 == NULL )
9944 return NULL;
9945 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9946 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
9947 }
9948 {
9949 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9950 if ( tmp3 == NULL )
9951 return NULL;
9952 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9953 {
9954 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9955 return NULL;
9956 }
9957 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9958 }
9959 {
9960 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9961 if ( tmp4 == NULL )
9962 return NULL;
9963 if ( PyArray_DIMS( tmp4 )[0] != Alen )
9964 {
9965 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9966 return NULL;
9967 }
9968 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9969 }
9970 {
9971 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[3], NPY_PLINT, 1, 1 );
9972 if ( tmp5 == NULL )
9973 return NULL;
9974 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
9975 {
9976 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
9977 return NULL;
9978 }
9979 arg5 = (PLINT *) PyArray_DATA( tmp5 );
9980 }
9981 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
9982 if (!SWIG_IsOK(ecode6)) {
9983 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
9984 }
9985 arg6 = (PLBOOL)(val6);
9986 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
9987 resultobj = SWIG_Py_Void();
9988 {
9989 Py_CLEAR( tmp1 );
9990 }
9991 {
9992 Py_CLEAR( tmp3 );
9993 }
9994 {
9995 Py_CLEAR( tmp4 );
9996 }
9997 {
9998 Py_CLEAR( tmp5 );
9999 }
10000 return resultobj;
10001fail:
10002 {
10003 Py_CLEAR( tmp1 );
10004 }
10005 {
10006 Py_CLEAR( tmp3 );
10007 }
10008 {
10009 Py_CLEAR( tmp4 );
10010 }
10011 {
10012 Py_CLEAR( tmp5 );
10013 }
10014 return NULL;
10015}
10016
10017
10018SWIGINTERN PyObject *_wrap_plprec(PyObject *self, PyObject *args) {
10019 PyObject *resultobj = 0;
10020 PLINT arg1 ;
10021 PLINT arg2 ;
10022 int val1 ;
10023 int ecode1 = 0 ;
10024 int val2 ;
10025 int ecode2 = 0 ;
10026 PyObject *swig_obj[2] ;
10027
10028 if (!SWIG_Python_UnpackTuple(args, "plprec", 2, 2, swig_obj)) SWIG_fail;
10029 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10030 if (!SWIG_IsOK(ecode1)) {
10031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10032 }
10033 arg1 = (PLINT)(val1);
10034 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10035 if (!SWIG_IsOK(ecode2)) {
10036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10037 }
10038 arg2 = (PLINT)(val2);
10039 plprec(arg1,arg2);
10040 resultobj = SWIG_Py_Void();
10041 return resultobj;
10042fail:
10043 return NULL;
10044}
10045
10046
10047SWIGINTERN PyObject *_wrap_plpsty(PyObject *self, PyObject *args) {
10048 PyObject *resultobj = 0;
10049 PLINT arg1 ;
10050 int val1 ;
10051 int ecode1 = 0 ;
10052 PyObject *swig_obj[1] ;
10053
10054 if (!args) SWIG_fail;
10055 swig_obj[0] = args;
10056 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10057 if (!SWIG_IsOK(ecode1)) {
10058 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10059 }
10060 arg1 = (PLINT)(val1);
10061 plpsty(arg1);
10062 resultobj = SWIG_Py_Void();
10063 return resultobj;
10064fail:
10065 return NULL;
10066}
10067
10068
10069SWIGINTERN PyObject *_wrap_plptex(PyObject *self, PyObject *args) {
10070 PyObject *resultobj = 0;
10071 PLFLT arg1 ;
10072 PLFLT arg2 ;
10073 PLFLT arg3 ;
10074 PLFLT arg4 ;
10075 PLFLT arg5 ;
10076 char *arg6 = (char *) 0 ;
10077 double val1 ;
10078 int ecode1 = 0 ;
10079 double val2 ;
10080 int ecode2 = 0 ;
10081 double val3 ;
10082 int ecode3 = 0 ;
10083 double val4 ;
10084 int ecode4 = 0 ;
10085 double val5 ;
10086 int ecode5 = 0 ;
10087 int res6 ;
10088 char *buf6 = 0 ;
10089 int alloc6 = 0 ;
10090 PyObject *swig_obj[6] ;
10091
10092 if (!SWIG_Python_UnpackTuple(args, "plptex", 6, 6, swig_obj)) SWIG_fail;
10093 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10094 if (!SWIG_IsOK(ecode1)) {
10095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10096 }
10097 arg1 = (PLFLT)(val1);
10098 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10099 if (!SWIG_IsOK(ecode2)) {
10100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10101 }
10102 arg2 = (PLFLT)(val2);
10103 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10104 if (!SWIG_IsOK(ecode3)) {
10105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10106 }
10107 arg3 = (PLFLT)(val3);
10108 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10109 if (!SWIG_IsOK(ecode4)) {
10110 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10111 }
10112 arg4 = (PLFLT)(val4);
10113 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10114 if (!SWIG_IsOK(ecode5)) {
10115 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10116 }
10117 arg5 = (PLFLT)(val5);
10118 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
10119 if (!SWIG_IsOK(res6)) {
10120 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10121 }
10122 arg6 = (char *)(buf6);
10123 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10124 resultobj = SWIG_Py_Void();
10125 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10126 return resultobj;
10127fail:
10128 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10129 return NULL;
10130}
10131
10132
10133SWIGINTERN PyObject *_wrap_plptex3(PyObject *self, PyObject *args) {
10134 PyObject *resultobj = 0;
10135 PLFLT arg1 ;
10136 PLFLT arg2 ;
10137 PLFLT arg3 ;
10138 PLFLT arg4 ;
10139 PLFLT arg5 ;
10140 PLFLT arg6 ;
10141 PLFLT arg7 ;
10142 PLFLT arg8 ;
10143 PLFLT arg9 ;
10144 PLFLT arg10 ;
10145 char *arg11 = (char *) 0 ;
10146 double val1 ;
10147 int ecode1 = 0 ;
10148 double val2 ;
10149 int ecode2 = 0 ;
10150 double val3 ;
10151 int ecode3 = 0 ;
10152 double val4 ;
10153 int ecode4 = 0 ;
10154 double val5 ;
10155 int ecode5 = 0 ;
10156 double val6 ;
10157 int ecode6 = 0 ;
10158 double val7 ;
10159 int ecode7 = 0 ;
10160 double val8 ;
10161 int ecode8 = 0 ;
10162 double val9 ;
10163 int ecode9 = 0 ;
10164 double val10 ;
10165 int ecode10 = 0 ;
10166 int res11 ;
10167 char *buf11 = 0 ;
10168 int alloc11 = 0 ;
10169 PyObject *swig_obj[11] ;
10170
10171 if (!SWIG_Python_UnpackTuple(args, "plptex3", 11, 11, swig_obj)) SWIG_fail;
10172 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10173 if (!SWIG_IsOK(ecode1)) {
10174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10175 }
10176 arg1 = (PLFLT)(val1);
10177 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10178 if (!SWIG_IsOK(ecode2)) {
10179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10180 }
10181 arg2 = (PLFLT)(val2);
10182 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10183 if (!SWIG_IsOK(ecode3)) {
10184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10185 }
10186 arg3 = (PLFLT)(val3);
10187 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10188 if (!SWIG_IsOK(ecode4)) {
10189 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10190 }
10191 arg4 = (PLFLT)(val4);
10192 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10193 if (!SWIG_IsOK(ecode5)) {
10194 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10195 }
10196 arg5 = (PLFLT)(val5);
10197 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
10198 if (!SWIG_IsOK(ecode6)) {
10199 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10200 }
10201 arg6 = (PLFLT)(val6);
10202 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
10203 if (!SWIG_IsOK(ecode7)) {
10204 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10205 }
10206 arg7 = (PLFLT)(val7);
10207 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
10208 if (!SWIG_IsOK(ecode8)) {
10209 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10210 }
10211 arg8 = (PLFLT)(val8);
10212 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
10213 if (!SWIG_IsOK(ecode9)) {
10214 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10215 }
10216 arg9 = (PLFLT)(val9);
10217 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
10218 if (!SWIG_IsOK(ecode10)) {
10219 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10220 }
10221 arg10 = (PLFLT)(val10);
10222 res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
10223 if (!SWIG_IsOK(res11)) {
10224 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10225 }
10226 arg11 = (char *)(buf11);
10227 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10228 resultobj = SWIG_Py_Void();
10229 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10230 return resultobj;
10231fail:
10232 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10233 return NULL;
10234}
10235
10236
10237SWIGINTERN PyObject *_wrap_plrandd(PyObject *self, PyObject *args) {
10238 PyObject *resultobj = 0;
10239 PLFLT result;
10240
10241 if (!SWIG_Python_UnpackTuple(args, "plrandd", 0, 0, 0)) SWIG_fail;
10242 result = (PLFLT)plrandd();
10243 resultobj = SWIG_From_double((double)(result));
10244 return resultobj;
10245fail:
10246 return NULL;
10247}
10248
10249
10250SWIGINTERN PyObject *_wrap_plreplot(PyObject *self, PyObject *args) {
10251 PyObject *resultobj = 0;
10252
10253 if (!SWIG_Python_UnpackTuple(args, "plreplot", 0, 0, 0)) SWIG_fail;
10254 plreplot();
10255 resultobj = SWIG_Py_Void();
10256 return resultobj;
10257fail:
10258 return NULL;
10259}
10260
10261
10262SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *self, PyObject *args) {
10263 PyObject *resultobj = 0;
10264 PLFLT arg1 ;
10265 PLFLT arg2 ;
10266 PLFLT arg3 ;
10267 PLFLT *arg4 = (PLFLT *) 0 ;
10268 PLFLT *arg5 = (PLFLT *) 0 ;
10269 PLFLT *arg6 = (PLFLT *) 0 ;
10270 double val1 ;
10271 int ecode1 = 0 ;
10272 double val2 ;
10273 int ecode2 = 0 ;
10274 double val3 ;
10275 int ecode3 = 0 ;
10276 PLFLT temp4 ;
10277 int res4 = SWIG_TMPOBJ ;
10278 PLFLT temp5 ;
10279 int res5 = SWIG_TMPOBJ ;
10280 PLFLT temp6 ;
10281 int res6 = SWIG_TMPOBJ ;
10282 PyObject *swig_obj[3] ;
10283
10284 arg4 = &temp4;
10285 arg5 = &temp5;
10286 arg6 = &temp6;
10287 if (!SWIG_Python_UnpackTuple(args, "plrgbhls", 3, 3, swig_obj)) SWIG_fail;
10288 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10289 if (!SWIG_IsOK(ecode1)) {
10290 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10291 }
10292 arg1 = (PLFLT)(val1);
10293 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10294 if (!SWIG_IsOK(ecode2)) {
10295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10296 }
10297 arg2 = (PLFLT)(val2);
10298 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10299 if (!SWIG_IsOK(ecode3)) {
10300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10301 }
10302 arg3 = (PLFLT)(val3);
10303 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10304 resultobj = SWIG_Py_Void();
10305 if (SWIG_IsTmpObj(res4)) {
10306 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10307 } else {
10308 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10309 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10310 }
10311 if (SWIG_IsTmpObj(res5)) {
10312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10313 } else {
10314 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10316 }
10317 if (SWIG_IsTmpObj(res6)) {
10318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10319 } else {
10320 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10322 }
10323 return resultobj;
10324fail:
10325 return NULL;
10326}
10327
10328
10329SWIGINTERN PyObject *_wrap_plschr(PyObject *self, PyObject *args) {
10330 PyObject *resultobj = 0;
10331 PLFLT arg1 ;
10332 PLFLT arg2 ;
10333 double val1 ;
10334 int ecode1 = 0 ;
10335 double val2 ;
10336 int ecode2 = 0 ;
10337 PyObject *swig_obj[2] ;
10338
10339 if (!SWIG_Python_UnpackTuple(args, "plschr", 2, 2, swig_obj)) SWIG_fail;
10340 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10341 if (!SWIG_IsOK(ecode1)) {
10342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10343 }
10344 arg1 = (PLFLT)(val1);
10345 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10346 if (!SWIG_IsOK(ecode2)) {
10347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10348 }
10349 arg2 = (PLFLT)(val2);
10350 plschr(arg1,arg2);
10351 resultobj = SWIG_Py_Void();
10352 return resultobj;
10353fail:
10354 return NULL;
10355}
10356
10357
10358SWIGINTERN PyObject *_wrap_plscmap0(PyObject *self, PyObject *args) {
10359 PyObject *resultobj = 0;
10360 PLINT *arg1 = (PLINT *) 0 ;
10361 PLINT *arg2 = (PLINT *) 0 ;
10362 PLINT *arg3 = (PLINT *) 0 ;
10363 PLINT arg4 ;
10364 PyArrayObject *tmp1 = NULL ;
10365 PyArrayObject *tmp2 = NULL ;
10366 PyArrayObject *tmp3 = NULL ;
10367 PyObject *swig_obj[3] ;
10368
10369 if (!SWIG_Python_UnpackTuple(args, "plscmap0", 3, 3, swig_obj)) SWIG_fail;
10370 {
10371 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10372 if ( tmp1 == NULL )
10373 return NULL;
10374 Alen = PyArray_DIMS( tmp1 )[0];
10375 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10376 }
10377 {
10378 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10379 if ( tmp2 == NULL )
10380 return NULL;
10381 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10382 {
10383 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10384 return NULL;
10385 }
10386 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10387 }
10388 {
10389 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10390 if ( tmp3 == NULL )
10391 return NULL;
10392 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10393 {
10394 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10395 return NULL;
10396 }
10397 arg4 = PyArray_DIMS( tmp3 )[0];
10398 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10399 }
10400 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10401 resultobj = SWIG_Py_Void();
10402 {
10403 Py_CLEAR( tmp1 );
10404 }
10405 {
10406 Py_CLEAR( tmp2 );
10407 }
10408 {
10409 Py_CLEAR( tmp3 );
10410 }
10411 return resultobj;
10412fail:
10413 {
10414 Py_CLEAR( tmp1 );
10415 }
10416 {
10417 Py_CLEAR( tmp2 );
10418 }
10419 {
10420 Py_CLEAR( tmp3 );
10421 }
10422 return NULL;
10423}
10424
10425
10426SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *self, PyObject *args) {
10427 PyObject *resultobj = 0;
10428 PLINT *arg1 = (PLINT *) 0 ;
10429 PLINT *arg2 = (PLINT *) 0 ;
10430 PLINT *arg3 = (PLINT *) 0 ;
10431 PLFLT *arg4 = (PLFLT *) 0 ;
10432 PLINT arg5 ;
10433 PyArrayObject *tmp1 = NULL ;
10434 PyArrayObject *tmp2 = NULL ;
10435 PyArrayObject *tmp3 = NULL ;
10436 PyArrayObject *tmp4 = NULL ;
10437 PyObject *swig_obj[4] ;
10438
10439 if (!SWIG_Python_UnpackTuple(args, "plscmap0a", 4, 4, swig_obj)) SWIG_fail;
10440 {
10441 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10442 if ( tmp1 == NULL )
10443 return NULL;
10444 Alen = PyArray_DIMS( tmp1 )[0];
10445 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10446 }
10447 {
10448 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10449 if ( tmp2 == NULL )
10450 return NULL;
10451 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10452 {
10453 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10454 return NULL;
10455 }
10456 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10457 }
10458 {
10459 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10460 if ( tmp3 == NULL )
10461 return NULL;
10462 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10463 {
10464 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10465 return NULL;
10466 }
10467 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10468 }
10469 {
10470 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10471 if ( tmp4 == NULL )
10472 return NULL;
10473 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10474 {
10475 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10476 return NULL;
10477 }
10478 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10479 arg5 = PyArray_DIMS( tmp4 )[0];
10480 }
10481 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10482 resultobj = SWIG_Py_Void();
10483 {
10484 Py_CLEAR( tmp1 );
10485 }
10486 {
10487 Py_CLEAR( tmp2 );
10488 }
10489 {
10490 Py_CLEAR( tmp3 );
10491 }
10492 {
10493 Py_CLEAR( tmp4 );
10494 }
10495 return resultobj;
10496fail:
10497 {
10498 Py_CLEAR( tmp1 );
10499 }
10500 {
10501 Py_CLEAR( tmp2 );
10502 }
10503 {
10504 Py_CLEAR( tmp3 );
10505 }
10506 {
10507 Py_CLEAR( tmp4 );
10508 }
10509 return NULL;
10510}
10511
10512
10513SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *self, PyObject *args) {
10514 PyObject *resultobj = 0;
10515 PLINT arg1 ;
10516 int val1 ;
10517 int ecode1 = 0 ;
10518 PyObject *swig_obj[1] ;
10519
10520 if (!args) SWIG_fail;
10521 swig_obj[0] = args;
10522 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10523 if (!SWIG_IsOK(ecode1)) {
10524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10525 }
10526 arg1 = (PLINT)(val1);
10527 plscmap0n(arg1);
10528 resultobj = SWIG_Py_Void();
10529 return resultobj;
10530fail:
10531 return NULL;
10532}
10533
10534
10535SWIGINTERN PyObject *_wrap_plscmap1(PyObject *self, PyObject *args) {
10536 PyObject *resultobj = 0;
10537 PLINT *arg1 = (PLINT *) 0 ;
10538 PLINT *arg2 = (PLINT *) 0 ;
10539 PLINT *arg3 = (PLINT *) 0 ;
10540 PLINT arg4 ;
10541 PyArrayObject *tmp1 = NULL ;
10542 PyArrayObject *tmp2 = NULL ;
10543 PyArrayObject *tmp3 = NULL ;
10544 PyObject *swig_obj[3] ;
10545
10546 if (!SWIG_Python_UnpackTuple(args, "plscmap1", 3, 3, swig_obj)) SWIG_fail;
10547 {
10548 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10549 if ( tmp1 == NULL )
10550 return NULL;
10551 Alen = PyArray_DIMS( tmp1 )[0];
10552 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10553 }
10554 {
10555 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10556 if ( tmp2 == NULL )
10557 return NULL;
10558 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10559 {
10560 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10561 return NULL;
10562 }
10563 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10564 }
10565 {
10566 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10567 if ( tmp3 == NULL )
10568 return NULL;
10569 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10570 {
10571 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10572 return NULL;
10573 }
10574 arg4 = PyArray_DIMS( tmp3 )[0];
10575 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10576 }
10577 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10578 resultobj = SWIG_Py_Void();
10579 {
10580 Py_CLEAR( tmp1 );
10581 }
10582 {
10583 Py_CLEAR( tmp2 );
10584 }
10585 {
10586 Py_CLEAR( tmp3 );
10587 }
10588 return resultobj;
10589fail:
10590 {
10591 Py_CLEAR( tmp1 );
10592 }
10593 {
10594 Py_CLEAR( tmp2 );
10595 }
10596 {
10597 Py_CLEAR( tmp3 );
10598 }
10599 return NULL;
10600}
10601
10602
10603SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *self, PyObject *args) {
10604 PyObject *resultobj = 0;
10605 PLINT *arg1 = (PLINT *) 0 ;
10606 PLINT *arg2 = (PLINT *) 0 ;
10607 PLINT *arg3 = (PLINT *) 0 ;
10608 PLFLT *arg4 = (PLFLT *) 0 ;
10609 PLINT arg5 ;
10610 PyArrayObject *tmp1 = NULL ;
10611 PyArrayObject *tmp2 = NULL ;
10612 PyArrayObject *tmp3 = NULL ;
10613 PyArrayObject *tmp4 = NULL ;
10614 PyObject *swig_obj[4] ;
10615
10616 if (!SWIG_Python_UnpackTuple(args, "plscmap1a", 4, 4, swig_obj)) SWIG_fail;
10617 {
10618 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10619 if ( tmp1 == NULL )
10620 return NULL;
10621 Alen = PyArray_DIMS( tmp1 )[0];
10622 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10623 }
10624 {
10625 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10626 if ( tmp2 == NULL )
10627 return NULL;
10628 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10629 {
10630 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10631 return NULL;
10632 }
10633 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10634 }
10635 {
10636 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10637 if ( tmp3 == NULL )
10638 return NULL;
10639 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10640 {
10641 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10642 return NULL;
10643 }
10644 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10645 }
10646 {
10647 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10648 if ( tmp4 == NULL )
10649 return NULL;
10650 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10651 {
10652 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10653 return NULL;
10654 }
10655 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10656 arg5 = PyArray_DIMS( tmp4 )[0];
10657 }
10658 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10659 resultobj = SWIG_Py_Void();
10660 {
10661 Py_CLEAR( tmp1 );
10662 }
10663 {
10664 Py_CLEAR( tmp2 );
10665 }
10666 {
10667 Py_CLEAR( tmp3 );
10668 }
10669 {
10670 Py_CLEAR( tmp4 );
10671 }
10672 return resultobj;
10673fail:
10674 {
10675 Py_CLEAR( tmp1 );
10676 }
10677 {
10678 Py_CLEAR( tmp2 );
10679 }
10680 {
10681 Py_CLEAR( tmp3 );
10682 }
10683 {
10684 Py_CLEAR( tmp4 );
10685 }
10686 return NULL;
10687}
10688
10689
10690SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *self, PyObject *args) {
10691 PyObject *resultobj = 0;
10692 PLBOOL arg1 ;
10693 PLINT arg2 ;
10694 PLFLT *arg3 = (PLFLT *) 0 ;
10695 PLFLT *arg4 = (PLFLT *) 0 ;
10696 PLFLT *arg5 = (PLFLT *) 0 ;
10697 PLFLT *arg6 = (PLFLT *) 0 ;
10698 PLBOOL *arg7 = (PLBOOL *) 0 ;
10699 int val1 ;
10700 int ecode1 = 0 ;
10701 PyArrayObject *tmp2 = NULL ;
10702 PyArrayObject *tmp4 = NULL ;
10703 PyArrayObject *tmp5 = NULL ;
10704 PyArrayObject *tmp6 = NULL ;
10705 PyArrayObject *tmp7 = NULL ;
10706 PyObject *swig_obj[6] ;
10707
10708 if (!SWIG_Python_UnpackTuple(args, "plscmap1l", 6, 6, swig_obj)) SWIG_fail;
10709 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10710 if (!SWIG_IsOK(ecode1)) {
10711 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
10712 }
10713 arg1 = (PLBOOL)(val1);
10714 {
10715 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10716 if ( tmp2 == NULL )
10717 return NULL;
10718 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10719 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10720 }
10721 {
10722 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10723 if ( tmp4 == NULL )
10724 return NULL;
10725 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10726 {
10727 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10728 return NULL;
10729 }
10730 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10731 }
10732 {
10733 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10734 if ( tmp5 == NULL )
10735 return NULL;
10736 if ( PyArray_DIMS( tmp5 )[0] != Alen )
10737 {
10738 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10739 return NULL;
10740 }
10741 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10742 }
10743 {
10744 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
10745 if ( tmp6 == NULL )
10746 return NULL;
10747 if ( PyArray_DIMS( tmp6 )[0] != Alen )
10748 {
10749 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10750 return NULL;
10751 }
10752 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10753 }
10754 {
10755 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[5], NPY_PLINT, 1, 1 );
10756 if ( tmp7 == NULL )
10757 return NULL;
10758 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
10759 {
10760 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10761 return NULL;
10762 }
10763 arg7 = (PLINT *) PyArray_DATA( tmp7 );
10764 }
10765 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
10766 resultobj = SWIG_Py_Void();
10767 {
10768 Py_CLEAR( tmp2 );
10769 }
10770 {
10771 Py_CLEAR( tmp4 );
10772 }
10773 {
10774 Py_CLEAR( tmp5 );
10775 }
10776 {
10777 Py_CLEAR( tmp6 );
10778 }
10779 {
10780 Py_CLEAR( tmp7 );
10781 }
10782 return resultobj;
10783fail:
10784 {
10785 Py_CLEAR( tmp2 );
10786 }
10787 {
10788 Py_CLEAR( tmp4 );
10789 }
10790 {
10791 Py_CLEAR( tmp5 );
10792 }
10793 {
10794 Py_CLEAR( tmp6 );
10795 }
10796 {
10797 Py_CLEAR( tmp7 );
10798 }
10799 return NULL;
10800}
10801
10802
10803SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *self, PyObject *args) {
10804 PyObject *resultobj = 0;
10805 PLBOOL arg1 ;
10806 PLINT arg2 ;
10807 PLFLT *arg3 = (PLFLT *) 0 ;
10808 PLFLT *arg4 = (PLFLT *) 0 ;
10809 PLFLT *arg5 = (PLFLT *) 0 ;
10810 PLFLT *arg6 = (PLFLT *) 0 ;
10811 PLFLT *arg7 = (PLFLT *) 0 ;
10812 PLBOOL *arg8 = (PLBOOL *) 0 ;
10813 int val1 ;
10814 int ecode1 = 0 ;
10815 PyArrayObject *tmp2 = NULL ;
10816 PyArrayObject *tmp4 = NULL ;
10817 PyArrayObject *tmp5 = NULL ;
10818 PyArrayObject *tmp6 = NULL ;
10819 PyArrayObject *tmp7 = NULL ;
10820 PyArrayObject *tmp8 = NULL ;
10821 PyObject *swig_obj[7] ;
10822
10823 if (!SWIG_Python_UnpackTuple(args, "plscmap1la", 7, 7, swig_obj)) SWIG_fail;
10824 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10825 if (!SWIG_IsOK(ecode1)) {
10826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
10827 }
10828 arg1 = (PLBOOL)(val1);
10829 {
10830 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10831 if ( tmp2 == NULL )
10832 return NULL;
10833 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
10834 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
10835 }
10836 {
10837 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10838 if ( tmp4 == NULL )
10839 return NULL;
10840 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10841 {
10842 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10843 return NULL;
10844 }
10845 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10846 }
10847 {
10848 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10849 if ( tmp5 == NULL )
10850 return NULL;
10851 if ( PyArray_DIMS( tmp5 )[0] != Alen )
10852 {
10853 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10854 return NULL;
10855 }
10856 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
10857 }
10858 {
10859 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
10860 if ( tmp6 == NULL )
10861 return NULL;
10862 if ( PyArray_DIMS( tmp6 )[0] != Alen )
10863 {
10864 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10865 return NULL;
10866 }
10867 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
10868 }
10869 {
10870 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
10871 if ( tmp7 == NULL )
10872 return NULL;
10873 if ( PyArray_DIMS( tmp7 )[0] != Alen )
10874 {
10875 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10876 return NULL;
10877 }
10878 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
10879 }
10880 {
10881 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
10882 if ( tmp8 == NULL )
10883 return NULL;
10884 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
10885 {
10886 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10887 return NULL;
10888 }
10889 arg8 = (PLINT *) PyArray_DATA( tmp8 );
10890 }
10891 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
10892 resultobj = SWIG_Py_Void();
10893 {
10894 Py_CLEAR( tmp2 );
10895 }
10896 {
10897 Py_CLEAR( tmp4 );
10898 }
10899 {
10900 Py_CLEAR( tmp5 );
10901 }
10902 {
10903 Py_CLEAR( tmp6 );
10904 }
10905 {
10906 Py_CLEAR( tmp7 );
10907 }
10908 {
10909 Py_CLEAR( tmp8 );
10910 }
10911 return resultobj;
10912fail:
10913 {
10914 Py_CLEAR( tmp2 );
10915 }
10916 {
10917 Py_CLEAR( tmp4 );
10918 }
10919 {
10920 Py_CLEAR( tmp5 );
10921 }
10922 {
10923 Py_CLEAR( tmp6 );
10924 }
10925 {
10926 Py_CLEAR( tmp7 );
10927 }
10928 {
10929 Py_CLEAR( tmp8 );
10930 }
10931 return NULL;
10932}
10933
10934
10935SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *self, PyObject *args) {
10936 PyObject *resultobj = 0;
10937 PLINT arg1 ;
10938 int val1 ;
10939 int ecode1 = 0 ;
10940 PyObject *swig_obj[1] ;
10941
10942 if (!args) SWIG_fail;
10943 swig_obj[0] = args;
10944 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10945 if (!SWIG_IsOK(ecode1)) {
10946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
10947 }
10948 arg1 = (PLINT)(val1);
10949 plscmap1n(arg1);
10950 resultobj = SWIG_Py_Void();
10951 return resultobj;
10952fail:
10953 return NULL;
10954}
10955
10956
10957SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *self, PyObject *args) {
10958 PyObject *resultobj = 0;
10959 PLFLT arg1 ;
10960 PLFLT arg2 ;
10961 double val1 ;
10962 int ecode1 = 0 ;
10963 double val2 ;
10964 int ecode2 = 0 ;
10965 PyObject *swig_obj[2] ;
10966
10967 if (!SWIG_Python_UnpackTuple(args, "plscmap1_range", 2, 2, swig_obj)) SWIG_fail;
10968 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10969 if (!SWIG_IsOK(ecode1)) {
10970 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
10971 }
10972 arg1 = (PLFLT)(val1);
10973 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10974 if (!SWIG_IsOK(ecode2)) {
10975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
10976 }
10977 arg2 = (PLFLT)(val2);
10978 plscmap1_range(arg1,arg2);
10979 resultobj = SWIG_Py_Void();
10980 return resultobj;
10981fail:
10982 return NULL;
10983}
10984
10985
10986SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *self, PyObject *args) {
10987 PyObject *resultobj = 0;
10988 PLFLT *arg1 = (PLFLT *) 0 ;
10989 PLFLT *arg2 = (PLFLT *) 0 ;
10990 PLFLT temp1 ;
10991 int res1 = SWIG_TMPOBJ ;
10992 PLFLT temp2 ;
10993 int res2 = SWIG_TMPOBJ ;
10994
10995 arg1 = &temp1;
10996 arg2 = &temp2;
10997 if (!SWIG_Python_UnpackTuple(args, "plgcmap1_range", 0, 0, 0)) SWIG_fail;
10998 plgcmap1_range(arg1,arg2);
10999 resultobj = SWIG_Py_Void();
11000 if (SWIG_IsTmpObj(res1)) {
11001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
11002 } else {
11003 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11005 }
11006 if (SWIG_IsTmpObj(res2)) {
11007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
11008 } else {
11009 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11011 }
11012 return resultobj;
11013fail:
11014 return NULL;
11015}
11016
11017
11018SWIGINTERN PyObject *_wrap_plscol0(PyObject *self, PyObject *args) {
11019 PyObject *resultobj = 0;
11020 PLINT arg1 ;
11021 PLINT arg2 ;
11022 PLINT arg3 ;
11023 PLINT arg4 ;
11024 int val1 ;
11025 int ecode1 = 0 ;
11026 int val2 ;
11027 int ecode2 = 0 ;
11028 int val3 ;
11029 int ecode3 = 0 ;
11030 int val4 ;
11031 int ecode4 = 0 ;
11032 PyObject *swig_obj[4] ;
11033
11034 if (!SWIG_Python_UnpackTuple(args, "plscol0", 4, 4, swig_obj)) SWIG_fail;
11035 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11036 if (!SWIG_IsOK(ecode1)) {
11037 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11038 }
11039 arg1 = (PLINT)(val1);
11040 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11041 if (!SWIG_IsOK(ecode2)) {
11042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11043 }
11044 arg2 = (PLINT)(val2);
11045 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11046 if (!SWIG_IsOK(ecode3)) {
11047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11048 }
11049 arg3 = (PLINT)(val3);
11050 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11051 if (!SWIG_IsOK(ecode4)) {
11052 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11053 }
11054 arg4 = (PLINT)(val4);
11055 plscol0(arg1,arg2,arg3,arg4);
11056 resultobj = SWIG_Py_Void();
11057 return resultobj;
11058fail:
11059 return NULL;
11060}
11061
11062
11063SWIGINTERN PyObject *_wrap_plscol0a(PyObject *self, PyObject *args) {
11064 PyObject *resultobj = 0;
11065 PLINT arg1 ;
11066 PLINT arg2 ;
11067 PLINT arg3 ;
11068 PLINT arg4 ;
11069 PLFLT arg5 ;
11070 int val1 ;
11071 int ecode1 = 0 ;
11072 int val2 ;
11073 int ecode2 = 0 ;
11074 int val3 ;
11075 int ecode3 = 0 ;
11076 int val4 ;
11077 int ecode4 = 0 ;
11078 double val5 ;
11079 int ecode5 = 0 ;
11080 PyObject *swig_obj[5] ;
11081
11082 if (!SWIG_Python_UnpackTuple(args, "plscol0a", 5, 5, swig_obj)) SWIG_fail;
11083 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11084 if (!SWIG_IsOK(ecode1)) {
11085 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11086 }
11087 arg1 = (PLINT)(val1);
11088 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11089 if (!SWIG_IsOK(ecode2)) {
11090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11091 }
11092 arg2 = (PLINT)(val2);
11093 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11094 if (!SWIG_IsOK(ecode3)) {
11095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11096 }
11097 arg3 = (PLINT)(val3);
11098 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11099 if (!SWIG_IsOK(ecode4)) {
11100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11101 }
11102 arg4 = (PLINT)(val4);
11103 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11104 if (!SWIG_IsOK(ecode5)) {
11105 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11106 }
11107 arg5 = (PLFLT)(val5);
11108 plscol0a(arg1,arg2,arg3,arg4,arg5);
11109 resultobj = SWIG_Py_Void();
11110 return resultobj;
11111fail:
11112 return NULL;
11113}
11114
11115
11116SWIGINTERN PyObject *_wrap_plscolbg(PyObject *self, PyObject *args) {
11117 PyObject *resultobj = 0;
11118 PLINT arg1 ;
11119 PLINT arg2 ;
11120 PLINT arg3 ;
11121 int val1 ;
11122 int ecode1 = 0 ;
11123 int val2 ;
11124 int ecode2 = 0 ;
11125 int val3 ;
11126 int ecode3 = 0 ;
11127 PyObject *swig_obj[3] ;
11128
11129 if (!SWIG_Python_UnpackTuple(args, "plscolbg", 3, 3, swig_obj)) SWIG_fail;
11130 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11131 if (!SWIG_IsOK(ecode1)) {
11132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11133 }
11134 arg1 = (PLINT)(val1);
11135 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11136 if (!SWIG_IsOK(ecode2)) {
11137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11138 }
11139 arg2 = (PLINT)(val2);
11140 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11141 if (!SWIG_IsOK(ecode3)) {
11142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11143 }
11144 arg3 = (PLINT)(val3);
11145 plscolbg(arg1,arg2,arg3);
11146 resultobj = SWIG_Py_Void();
11147 return resultobj;
11148fail:
11149 return NULL;
11150}
11151
11152
11153SWIGINTERN PyObject *_wrap_plscolbga(PyObject *self, PyObject *args) {
11154 PyObject *resultobj = 0;
11155 PLINT arg1 ;
11156 PLINT arg2 ;
11157 PLINT arg3 ;
11158 PLFLT arg4 ;
11159 int val1 ;
11160 int ecode1 = 0 ;
11161 int val2 ;
11162 int ecode2 = 0 ;
11163 int val3 ;
11164 int ecode3 = 0 ;
11165 double val4 ;
11166 int ecode4 = 0 ;
11167 PyObject *swig_obj[4] ;
11168
11169 if (!SWIG_Python_UnpackTuple(args, "plscolbga", 4, 4, swig_obj)) SWIG_fail;
11170 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11171 if (!SWIG_IsOK(ecode1)) {
11172 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11173 }
11174 arg1 = (PLINT)(val1);
11175 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11176 if (!SWIG_IsOK(ecode2)) {
11177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11178 }
11179 arg2 = (PLINT)(val2);
11180 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11181 if (!SWIG_IsOK(ecode3)) {
11182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11183 }
11184 arg3 = (PLINT)(val3);
11185 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11186 if (!SWIG_IsOK(ecode4)) {
11187 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11188 }
11189 arg4 = (PLFLT)(val4);
11190 plscolbga(arg1,arg2,arg3,arg4);
11191 resultobj = SWIG_Py_Void();
11192 return resultobj;
11193fail:
11194 return NULL;
11195}
11196
11197
11198SWIGINTERN PyObject *_wrap_plscolor(PyObject *self, PyObject *args) {
11199 PyObject *resultobj = 0;
11200 PLINT arg1 ;
11201 int 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_int(swig_obj[0], &val1);
11208 if (!SWIG_IsOK(ecode1)) {
11209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11210 }
11211 arg1 = (PLINT)(val1);
11212 plscolor(arg1);
11213 resultobj = SWIG_Py_Void();
11214 return resultobj;
11215fail:
11216 return NULL;
11217}
11218
11219
11220SWIGINTERN PyObject *_wrap_plscompression(PyObject *self, PyObject *args) {
11221 PyObject *resultobj = 0;
11222 PLINT arg1 ;
11223 int val1 ;
11224 int ecode1 = 0 ;
11225 PyObject *swig_obj[1] ;
11226
11227 if (!args) SWIG_fail;
11228 swig_obj[0] = args;
11229 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11230 if (!SWIG_IsOK(ecode1)) {
11231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11232 }
11233 arg1 = (PLINT)(val1);
11234 plscompression(arg1);
11235 resultobj = SWIG_Py_Void();
11236 return resultobj;
11237fail:
11238 return NULL;
11239}
11240
11241
11242SWIGINTERN PyObject *_wrap_plsdev(PyObject *self, PyObject *args) {
11243 PyObject *resultobj = 0;
11244 char *arg1 = (char *) 0 ;
11245 int res1 ;
11246 char *buf1 = 0 ;
11247 int alloc1 = 0 ;
11248 PyObject *swig_obj[1] ;
11249
11250 if (!args) SWIG_fail;
11251 swig_obj[0] = args;
11252 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11253 if (!SWIG_IsOK(res1)) {
11254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11255 }
11256 arg1 = (char *)(buf1);
11257 plsdev((char const *)arg1);
11258 resultobj = SWIG_Py_Void();
11259 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11260 return resultobj;
11261fail:
11262 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11263 return NULL;
11264}
11265
11266
11267SWIGINTERN PyObject *_wrap_plsdidev(PyObject *self, PyObject *args) {
11268 PyObject *resultobj = 0;
11269 PLFLT arg1 ;
11270 PLFLT arg2 ;
11271 PLFLT arg3 ;
11272 PLFLT arg4 ;
11273 double val1 ;
11274 int ecode1 = 0 ;
11275 double val2 ;
11276 int ecode2 = 0 ;
11277 double val3 ;
11278 int ecode3 = 0 ;
11279 double val4 ;
11280 int ecode4 = 0 ;
11281 PyObject *swig_obj[4] ;
11282
11283 if (!SWIG_Python_UnpackTuple(args, "plsdidev", 4, 4, swig_obj)) SWIG_fail;
11284 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11285 if (!SWIG_IsOK(ecode1)) {
11286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11287 }
11288 arg1 = (PLFLT)(val1);
11289 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11290 if (!SWIG_IsOK(ecode2)) {
11291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11292 }
11293 arg2 = (PLFLT)(val2);
11294 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11295 if (!SWIG_IsOK(ecode3)) {
11296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11297 }
11298 arg3 = (PLFLT)(val3);
11299 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11300 if (!SWIG_IsOK(ecode4)) {
11301 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11302 }
11303 arg4 = (PLFLT)(val4);
11304 plsdidev(arg1,arg2,arg3,arg4);
11305 resultobj = SWIG_Py_Void();
11306 return resultobj;
11307fail:
11308 return NULL;
11309}
11310
11311
11312SWIGINTERN PyObject *_wrap_plsdimap(PyObject *self, PyObject *args) {
11313 PyObject *resultobj = 0;
11314 PLINT arg1 ;
11315 PLINT arg2 ;
11316 PLINT arg3 ;
11317 PLINT arg4 ;
11318 PLFLT arg5 ;
11319 PLFLT arg6 ;
11320 int val1 ;
11321 int ecode1 = 0 ;
11322 int val2 ;
11323 int ecode2 = 0 ;
11324 int val3 ;
11325 int ecode3 = 0 ;
11326 int val4 ;
11327 int ecode4 = 0 ;
11328 double val5 ;
11329 int ecode5 = 0 ;
11330 double val6 ;
11331 int ecode6 = 0 ;
11332 PyObject *swig_obj[6] ;
11333
11334 if (!SWIG_Python_UnpackTuple(args, "plsdimap", 6, 6, swig_obj)) SWIG_fail;
11335 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11336 if (!SWIG_IsOK(ecode1)) {
11337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11338 }
11339 arg1 = (PLINT)(val1);
11340 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11341 if (!SWIG_IsOK(ecode2)) {
11342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11343 }
11344 arg2 = (PLINT)(val2);
11345 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11346 if (!SWIG_IsOK(ecode3)) {
11347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11348 }
11349 arg3 = (PLINT)(val3);
11350 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11351 if (!SWIG_IsOK(ecode4)) {
11352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11353 }
11354 arg4 = (PLINT)(val4);
11355 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11356 if (!SWIG_IsOK(ecode5)) {
11357 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11358 }
11359 arg5 = (PLFLT)(val5);
11360 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
11361 if (!SWIG_IsOK(ecode6)) {
11362 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11363 }
11364 arg6 = (PLFLT)(val6);
11365 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11366 resultobj = SWIG_Py_Void();
11367 return resultobj;
11368fail:
11369 return NULL;
11370}
11371
11372
11373SWIGINTERN PyObject *_wrap_plsdiori(PyObject *self, PyObject *args) {
11374 PyObject *resultobj = 0;
11375 PLFLT arg1 ;
11376 double val1 ;
11377 int ecode1 = 0 ;
11378 PyObject *swig_obj[1] ;
11379
11380 if (!args) SWIG_fail;
11381 swig_obj[0] = args;
11382 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11383 if (!SWIG_IsOK(ecode1)) {
11384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11385 }
11386 arg1 = (PLFLT)(val1);
11387 plsdiori(arg1);
11388 resultobj = SWIG_Py_Void();
11389 return resultobj;
11390fail:
11391 return NULL;
11392}
11393
11394
11395SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *self, PyObject *args) {
11396 PyObject *resultobj = 0;
11397 PLFLT arg1 ;
11398 PLFLT arg2 ;
11399 PLFLT arg3 ;
11400 PLFLT arg4 ;
11401 double val1 ;
11402 int ecode1 = 0 ;
11403 double val2 ;
11404 int ecode2 = 0 ;
11405 double val3 ;
11406 int ecode3 = 0 ;
11407 double val4 ;
11408 int ecode4 = 0 ;
11409 PyObject *swig_obj[4] ;
11410
11411 if (!SWIG_Python_UnpackTuple(args, "plsdiplt", 4, 4, swig_obj)) SWIG_fail;
11412 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11413 if (!SWIG_IsOK(ecode1)) {
11414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11415 }
11416 arg1 = (PLFLT)(val1);
11417 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11418 if (!SWIG_IsOK(ecode2)) {
11419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11420 }
11421 arg2 = (PLFLT)(val2);
11422 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11423 if (!SWIG_IsOK(ecode3)) {
11424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11425 }
11426 arg3 = (PLFLT)(val3);
11427 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11428 if (!SWIG_IsOK(ecode4)) {
11429 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11430 }
11431 arg4 = (PLFLT)(val4);
11432 plsdiplt(arg1,arg2,arg3,arg4);
11433 resultobj = SWIG_Py_Void();
11434 return resultobj;
11435fail:
11436 return NULL;
11437}
11438
11439
11440SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *self, PyObject *args) {
11441 PyObject *resultobj = 0;
11442 PLFLT arg1 ;
11443 PLFLT arg2 ;
11444 PLFLT arg3 ;
11445 PLFLT arg4 ;
11446 double val1 ;
11447 int ecode1 = 0 ;
11448 double val2 ;
11449 int ecode2 = 0 ;
11450 double val3 ;
11451 int ecode3 = 0 ;
11452 double val4 ;
11453 int ecode4 = 0 ;
11454 PyObject *swig_obj[4] ;
11455
11456 if (!SWIG_Python_UnpackTuple(args, "plsdiplz", 4, 4, swig_obj)) SWIG_fail;
11457 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11458 if (!SWIG_IsOK(ecode1)) {
11459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11460 }
11461 arg1 = (PLFLT)(val1);
11462 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11463 if (!SWIG_IsOK(ecode2)) {
11464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11465 }
11466 arg2 = (PLFLT)(val2);
11467 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11468 if (!SWIG_IsOK(ecode3)) {
11469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11470 }
11471 arg3 = (PLFLT)(val3);
11472 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11473 if (!SWIG_IsOK(ecode4)) {
11474 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11475 }
11476 arg4 = (PLFLT)(val4);
11477 plsdiplz(arg1,arg2,arg3,arg4);
11478 resultobj = SWIG_Py_Void();
11479 return resultobj;
11480fail:
11481 return NULL;
11482}
11483
11484
11485SWIGINTERN PyObject *_wrap_plseed(PyObject *self, PyObject *args) {
11486 PyObject *resultobj = 0;
11487 unsigned int arg1 ;
11488 unsigned int val1 ;
11489 int ecode1 = 0 ;
11490 PyObject *swig_obj[1] ;
11491
11492 if (!args) SWIG_fail;
11493 swig_obj[0] = args;
11494 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11495 if (!SWIG_IsOK(ecode1)) {
11496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11497 }
11498 arg1 = (unsigned int)(val1);
11499 plseed(arg1);
11500 resultobj = SWIG_Py_Void();
11501 return resultobj;
11502fail:
11503 return NULL;
11504}
11505
11506
11507SWIGINTERN PyObject *_wrap_plsesc(PyObject *self, PyObject *args) {
11508 PyObject *resultobj = 0;
11509 char arg1 ;
11510 char val1 ;
11511 int ecode1 = 0 ;
11512 PyObject *swig_obj[1] ;
11513
11514 if (!args) SWIG_fail;
11515 swig_obj[0] = args;
11516 ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
11517 if (!SWIG_IsOK(ecode1)) {
11518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11519 }
11520 arg1 = (char)(val1);
11521 plsesc(arg1);
11522 resultobj = SWIG_Py_Void();
11523 return resultobj;
11524fail:
11525 return NULL;
11526}
11527
11528
11529SWIGINTERN PyObject *_wrap_plsetopt(PyObject *self, PyObject *args) {
11530 PyObject *resultobj = 0;
11531 char *arg1 = (char *) 0 ;
11532 char *arg2 = (char *) 0 ;
11533 int res1 ;
11534 char *buf1 = 0 ;
11535 int alloc1 = 0 ;
11536 int res2 ;
11537 char *buf2 = 0 ;
11538 int alloc2 = 0 ;
11539 PyObject *swig_obj[2] ;
11540 PLINT result;
11541
11542 if (!SWIG_Python_UnpackTuple(args, "plsetopt", 2, 2, swig_obj)) SWIG_fail;
11543 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11544 if (!SWIG_IsOK(res1)) {
11545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11546 }
11547 arg1 = (char *)(buf1);
11548 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11549 if (!SWIG_IsOK(res2)) {
11550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11551 }
11552 arg2 = (char *)(buf2);
11553 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11554 resultobj = SWIG_From_int((int)(result));
11555 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11556 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11557 return resultobj;
11558fail:
11559 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11560 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11561 return NULL;
11562}
11563
11564
11565SWIGINTERN PyObject *_wrap_plsfam(PyObject *self, PyObject *args) {
11566 PyObject *resultobj = 0;
11567 PLINT arg1 ;
11568 PLINT arg2 ;
11569 PLINT arg3 ;
11570 int val1 ;
11571 int ecode1 = 0 ;
11572 int val2 ;
11573 int ecode2 = 0 ;
11574 int val3 ;
11575 int ecode3 = 0 ;
11576 PyObject *swig_obj[3] ;
11577
11578 if (!SWIG_Python_UnpackTuple(args, "plsfam", 3, 3, swig_obj)) SWIG_fail;
11579 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11580 if (!SWIG_IsOK(ecode1)) {
11581 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11582 }
11583 arg1 = (PLINT)(val1);
11584 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11585 if (!SWIG_IsOK(ecode2)) {
11586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11587 }
11588 arg2 = (PLINT)(val2);
11589 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11590 if (!SWIG_IsOK(ecode3)) {
11591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11592 }
11593 arg3 = (PLINT)(val3);
11594 plsfam(arg1,arg2,arg3);
11595 resultobj = SWIG_Py_Void();
11596 return resultobj;
11597fail:
11598 return NULL;
11599}
11600
11601
11602SWIGINTERN PyObject *_wrap_plsfci(PyObject *self, PyObject *args) {
11603 PyObject *resultobj = 0;
11604 PLUNICODE arg1 ;
11605 unsigned int val1 ;
11606 int ecode1 = 0 ;
11607 PyObject *swig_obj[1] ;
11608
11609 if (!args) SWIG_fail;
11610 swig_obj[0] = args;
11611 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11612 if (!SWIG_IsOK(ecode1)) {
11613 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11614 }
11615 arg1 = (PLUNICODE)(val1);
11616 plsfci(arg1);
11617 resultobj = SWIG_Py_Void();
11618 return resultobj;
11619fail:
11620 return NULL;
11621}
11622
11623
11624SWIGINTERN PyObject *_wrap_plsfnam(PyObject *self, PyObject *args) {
11625 PyObject *resultobj = 0;
11626 char *arg1 = (char *) 0 ;
11627 int res1 ;
11628 char *buf1 = 0 ;
11629 int alloc1 = 0 ;
11630 PyObject *swig_obj[1] ;
11631
11632 if (!args) SWIG_fail;
11633 swig_obj[0] = args;
11634 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11635 if (!SWIG_IsOK(res1)) {
11636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11637 }
11638 arg1 = (char *)(buf1);
11639 plsfnam((char const *)arg1);
11640 resultobj = SWIG_Py_Void();
11641 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11642 return resultobj;
11643fail:
11644 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11645 return NULL;
11646}
11647
11648
11649SWIGINTERN PyObject *_wrap_plsfont(PyObject *self, PyObject *args) {
11650 PyObject *resultobj = 0;
11651 PLINT arg1 ;
11652 PLINT arg2 ;
11653 PLINT arg3 ;
11654 int val1 ;
11655 int ecode1 = 0 ;
11656 int val2 ;
11657 int ecode2 = 0 ;
11658 int val3 ;
11659 int ecode3 = 0 ;
11660 PyObject *swig_obj[3] ;
11661
11662 if (!SWIG_Python_UnpackTuple(args, "plsfont", 3, 3, swig_obj)) SWIG_fail;
11663 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11664 if (!SWIG_IsOK(ecode1)) {
11665 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11666 }
11667 arg1 = (PLINT)(val1);
11668 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11669 if (!SWIG_IsOK(ecode2)) {
11670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11671 }
11672 arg2 = (PLINT)(val2);
11673 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11674 if (!SWIG_IsOK(ecode3)) {
11675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11676 }
11677 arg3 = (PLINT)(val3);
11678 plsfont(arg1,arg2,arg3);
11679 resultobj = SWIG_Py_Void();
11680 return resultobj;
11681fail:
11682 return NULL;
11683}
11684
11685
11686SWIGINTERN PyObject *_wrap_plshades(PyObject *self, PyObject *args) {
11687 PyObject *resultobj = 0;
11688 PLFLT **arg1 = (PLFLT **) 0 ;
11689 PLINT arg2 ;
11690 PLINT arg3 ;
11691 defined_func arg4 = (defined_func) 0 ;
11692 PLFLT arg5 ;
11693 PLFLT arg6 ;
11694 PLFLT arg7 ;
11695 PLFLT arg8 ;
11696 PLFLT *arg9 = (PLFLT *) 0 ;
11697 PLINT arg10 ;
11698 PLFLT arg11 ;
11699 PLINT arg12 ;
11700 PLFLT arg13 ;
11701 fill_func arg14 = (fill_func) 0 ;
11702 PLBOOL arg15 ;
11703 pltr_func arg16 = (pltr_func) 0 ;
11704 PLPointer arg17 = (PLPointer) 0 ;
11705 PyArrayObject *tmp1 = NULL ;
11706 double val5 ;
11707 int ecode5 = 0 ;
11708 double val6 ;
11709 int ecode6 = 0 ;
11710 double val7 ;
11711 int ecode7 = 0 ;
11712 double val8 ;
11713 int ecode8 = 0 ;
11714 PyArrayObject *tmp9 = NULL ;
11715 double val11 ;
11716 int ecode11 = 0 ;
11717 int val12 ;
11718 int ecode12 = 0 ;
11719 double val13 ;
11720 int ecode13 = 0 ;
11721 int val15 ;
11722 int ecode15 = 0 ;
11723 PyObject *swig_obj[12] ;
11724
11725 {
11726 python_pltr = 0;
11727 arg16 = NULL;
11728 }
11729 {
11730 arg17 = NULL;
11731 }
11732 {
11733 arg4 = NULL;
11734 }
11735 {
11736 arg14 = plfill;
11737 }
11738 if (!SWIG_Python_UnpackTuple(args, "plshades", 10, 12, swig_obj)) SWIG_fail;
11739 {
11740 int i, size;
11741 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
11742 if ( tmp1 == NULL )
11743 return NULL;
11744 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11745 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11746 size = arg3;
11747 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11748 for ( i = 0; i < arg2; i++ )
11749 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11750 }
11751 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
11752 if (!SWIG_IsOK(ecode5)) {
11753 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
11754 }
11755 arg5 = (PLFLT)(val5);
11756 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
11757 if (!SWIG_IsOK(ecode6)) {
11758 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
11759 }
11760 arg6 = (PLFLT)(val6);
11761 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
11762 if (!SWIG_IsOK(ecode7)) {
11763 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
11764 }
11765 arg7 = (PLFLT)(val7);
11766 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
11767 if (!SWIG_IsOK(ecode8)) {
11768 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
11769 }
11770 arg8 = (PLFLT)(val8);
11771 {
11772 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
11773 if ( tmp9 == NULL )
11774 return NULL;
11775 arg10 = PyArray_DIMS( tmp9 )[0];
11776 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
11777 }
11778 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
11779 if (!SWIG_IsOK(ecode11)) {
11780 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
11781 }
11782 arg11 = (PLFLT)(val11);
11783 ecode12 = SWIG_AsVal_int(swig_obj[7], &val12);
11784 if (!SWIG_IsOK(ecode12)) {
11785 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
11786 }
11787 arg12 = (PLINT)(val12);
11788 ecode13 = SWIG_AsVal_double(swig_obj[8], &val13);
11789 if (!SWIG_IsOK(ecode13)) {
11790 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
11791 }
11792 arg13 = (PLFLT)(val13);
11793 ecode15 = SWIG_AsVal_int(swig_obj[9], &val15);
11794 if (!SWIG_IsOK(ecode15)) {
11795 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
11796 }
11797 arg15 = (PLBOOL)(val15);
11798 if (swig_obj[10]) {
11799 {
11800 // it must be a callable or None
11801 if ( swig_obj[10] == Py_None )
11802 {
11803 arg16 = NULL;
11804 }
11805 else
11806 {
11807 if ( !PyCallable_Check( (PyObject *) swig_obj[10] ) )
11808 {
11809 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
11810 return NULL;
11811 }
11812 arg16 = marshal_pltr( swig_obj[10] );
11813 }
11814 }
11815 }
11816 if (swig_obj[11]) {
11817 {
11818 if ( swig_obj[11] == Py_None )
11819 arg17 = NULL;
11820 else
11821 {
11822 arg17 = marshal_PLPointer( swig_obj[11], 0 );
11823 }
11824 }
11825 }
11826 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
11827 resultobj = SWIG_Py_Void();
11828 {
11829 Py_CLEAR( tmp1 );
11830 free( arg1 );
11831 }
11832 {
11833 Py_CLEAR( tmp9 );
11834 }
11835 {
11836 cleanup_pltr();
11837 }
11838 {
11840 }
11841 return resultobj;
11842fail:
11843 {
11844 Py_CLEAR( tmp1 );
11845 free( arg1 );
11846 }
11847 {
11848 Py_CLEAR( tmp9 );
11849 }
11850 {
11851 cleanup_pltr();
11852 }
11853 {
11855 }
11856 return NULL;
11857}
11858
11859
11860SWIGINTERN PyObject *_wrap_plshade(PyObject *self, PyObject *args) {
11861 PyObject *resultobj = 0;
11862 PLFLT **arg1 = (PLFLT **) 0 ;
11863 PLINT arg2 ;
11864 PLINT arg3 ;
11865 defined_func arg4 = (defined_func) 0 ;
11866 PLFLT arg5 ;
11867 PLFLT arg6 ;
11868 PLFLT arg7 ;
11869 PLFLT arg8 ;
11870 PLFLT arg9 ;
11871 PLFLT arg10 ;
11872 PLINT arg11 ;
11873 PLFLT arg12 ;
11874 PLFLT arg13 ;
11875 PLINT arg14 ;
11876 PLFLT arg15 ;
11877 PLINT arg16 ;
11878 PLFLT arg17 ;
11879 fill_func arg18 = (fill_func) 0 ;
11880 PLBOOL arg19 ;
11881 pltr_func arg20 = (pltr_func) 0 ;
11882 PLPointer arg21 = (PLPointer) 0 ;
11883 PyArrayObject *tmp1 = NULL ;
11884 double val5 ;
11885 int ecode5 = 0 ;
11886 double val6 ;
11887 int ecode6 = 0 ;
11888 double val7 ;
11889 int ecode7 = 0 ;
11890 double val8 ;
11891 int ecode8 = 0 ;
11892 double val9 ;
11893 int ecode9 = 0 ;
11894 double val10 ;
11895 int ecode10 = 0 ;
11896 int val11 ;
11897 int ecode11 = 0 ;
11898 double val12 ;
11899 int ecode12 = 0 ;
11900 double val13 ;
11901 int ecode13 = 0 ;
11902 int val14 ;
11903 int ecode14 = 0 ;
11904 double val15 ;
11905 int ecode15 = 0 ;
11906 int val16 ;
11907 int ecode16 = 0 ;
11908 double val17 ;
11909 int ecode17 = 0 ;
11910 int val19 ;
11911 int ecode19 = 0 ;
11912 PyObject *swig_obj[17] ;
11913
11914 {
11915 python_pltr = 0;
11916 arg20 = NULL;
11917 }
11918 {
11919 arg21 = NULL;
11920 }
11921 {
11922 arg4 = NULL;
11923 }
11924 {
11925 arg18 = plfill;
11926 }
11927 if (!SWIG_Python_UnpackTuple(args, "plshade", 15, 17, swig_obj)) SWIG_fail;
11928 {
11929 int i, size;
11930 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
11931 if ( tmp1 == NULL )
11932 return NULL;
11933 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
11934 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
11935 size = arg3;
11936 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
11937 for ( i = 0; i < arg2; i++ )
11938 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
11939 }
11940 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
11941 if (!SWIG_IsOK(ecode5)) {
11942 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
11943 }
11944 arg5 = (PLFLT)(val5);
11945 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
11946 if (!SWIG_IsOK(ecode6)) {
11947 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
11948 }
11949 arg6 = (PLFLT)(val6);
11950 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
11951 if (!SWIG_IsOK(ecode7)) {
11952 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
11953 }
11954 arg7 = (PLFLT)(val7);
11955 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
11956 if (!SWIG_IsOK(ecode8)) {
11957 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
11958 }
11959 arg8 = (PLFLT)(val8);
11960 ecode9 = SWIG_AsVal_double(swig_obj[5], &val9);
11961 if (!SWIG_IsOK(ecode9)) {
11962 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
11963 }
11964 arg9 = (PLFLT)(val9);
11965 ecode10 = SWIG_AsVal_double(swig_obj[6], &val10);
11966 if (!SWIG_IsOK(ecode10)) {
11967 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
11968 }
11969 arg10 = (PLFLT)(val10);
11970 ecode11 = SWIG_AsVal_int(swig_obj[7], &val11);
11971 if (!SWIG_IsOK(ecode11)) {
11972 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
11973 }
11974 arg11 = (PLINT)(val11);
11975 ecode12 = SWIG_AsVal_double(swig_obj[8], &val12);
11976 if (!SWIG_IsOK(ecode12)) {
11977 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
11978 }
11979 arg12 = (PLFLT)(val12);
11980 ecode13 = SWIG_AsVal_double(swig_obj[9], &val13);
11981 if (!SWIG_IsOK(ecode13)) {
11982 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
11983 }
11984 arg13 = (PLFLT)(val13);
11985 ecode14 = SWIG_AsVal_int(swig_obj[10], &val14);
11986 if (!SWIG_IsOK(ecode14)) {
11987 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
11988 }
11989 arg14 = (PLINT)(val14);
11990 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
11991 if (!SWIG_IsOK(ecode15)) {
11992 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
11993 }
11994 arg15 = (PLFLT)(val15);
11995 ecode16 = SWIG_AsVal_int(swig_obj[12], &val16);
11996 if (!SWIG_IsOK(ecode16)) {
11997 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
11998 }
11999 arg16 = (PLINT)(val16);
12000 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
12001 if (!SWIG_IsOK(ecode17)) {
12002 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12003 }
12004 arg17 = (PLFLT)(val17);
12005 ecode19 = SWIG_AsVal_int(swig_obj[14], &val19);
12006 if (!SWIG_IsOK(ecode19)) {
12007 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12008 }
12009 arg19 = (PLBOOL)(val19);
12010 if (swig_obj[15]) {
12011 {
12012 // it must be a callable or None
12013 if ( swig_obj[15] == Py_None )
12014 {
12015 arg20 = NULL;
12016 }
12017 else
12018 {
12019 if ( !PyCallable_Check( (PyObject *) swig_obj[15] ) )
12020 {
12021 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12022 return NULL;
12023 }
12024 arg20 = marshal_pltr( swig_obj[15] );
12025 }
12026 }
12027 }
12028 if (swig_obj[16]) {
12029 {
12030 if ( swig_obj[16] == Py_None )
12031 arg21 = NULL;
12032 else
12033 {
12034 arg21 = marshal_PLPointer( swig_obj[16], 0 );
12035 }
12036 }
12037 }
12038 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12039 resultobj = SWIG_Py_Void();
12040 {
12041 Py_CLEAR( tmp1 );
12042 free( arg1 );
12043 }
12044 {
12045 cleanup_pltr();
12046 }
12047 {
12049 }
12050 return resultobj;
12051fail:
12052 {
12053 Py_CLEAR( tmp1 );
12054 free( arg1 );
12055 }
12056 {
12057 cleanup_pltr();
12058 }
12059 {
12061 }
12062 return NULL;
12063}
12064
12065
12066SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *self, PyObject *args) {
12067 PyObject *resultobj = 0;
12068 label_func arg1 = (label_func) 0 ;
12069 PLPointer arg2 = (PLPointer) 0 ;
12070 int res2 ;
12071 PyObject *swig_obj[2] ;
12072
12073 if (!SWIG_Python_UnpackTuple(args, "plslabelfunc", 2, 2, swig_obj)) SWIG_fail;
12074 {
12075 // Release reference to previous function if applicable
12076 if ( python_label )
12077 {
12078 Py_CLEAR( python_label );
12079 python_label = 0;
12080 }
12081 // it must be a callable or None
12082 if ( swig_obj[0] == Py_None )
12083 {
12084 arg1 = NULL;
12085 }
12086 else
12087 {
12088 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12089 {
12090 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12091 return NULL;
12092 }
12093 // hold a reference to it
12094 Py_XINCREF( (PyObject *) swig_obj[0] );
12095 python_label = (PyObject *) swig_obj[0];
12096 // this function handles calling the python function
12097 arg1 = do_label_callback;
12098 }
12099 }
12100 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12101 if (!SWIG_IsOK(res2)) {
12102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12103 }
12104 plslabelfunc(arg1,arg2);
12105 resultobj = SWIG_Py_Void();
12106 return resultobj;
12107fail:
12108 return NULL;
12109}
12110
12111
12112SWIGINTERN PyObject *_wrap_plsmaj(PyObject *self, PyObject *args) {
12113 PyObject *resultobj = 0;
12114 PLFLT arg1 ;
12115 PLFLT arg2 ;
12116 double val1 ;
12117 int ecode1 = 0 ;
12118 double val2 ;
12119 int ecode2 = 0 ;
12120 PyObject *swig_obj[2] ;
12121
12122 if (!SWIG_Python_UnpackTuple(args, "plsmaj", 2, 2, swig_obj)) SWIG_fail;
12123 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12124 if (!SWIG_IsOK(ecode1)) {
12125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12126 }
12127 arg1 = (PLFLT)(val1);
12128 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12129 if (!SWIG_IsOK(ecode2)) {
12130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12131 }
12132 arg2 = (PLFLT)(val2);
12133 plsmaj(arg1,arg2);
12134 resultobj = SWIG_Py_Void();
12135 return resultobj;
12136fail:
12137 return NULL;
12138}
12139
12140
12141SWIGINTERN PyObject *_wrap_plsmem(PyObject *self, PyObject *args) {
12142 PyObject *resultobj = 0;
12143 PLINT arg1 ;
12144 PLINT arg2 ;
12145 void *arg3 = (void *) 0 ;
12146 int val1 ;
12147 int ecode1 = 0 ;
12148 int val2 ;
12149 int ecode2 = 0 ;
12150 PyObject *swig_obj[3] ;
12151
12152 if (!SWIG_Python_UnpackTuple(args, "plsmem", 3, 3, swig_obj)) SWIG_fail;
12153 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12154 if (!SWIG_IsOK(ecode1)) {
12155 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12156 }
12157 arg1 = (PLINT)(val1);
12158 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12159 if (!SWIG_IsOK(ecode2)) {
12160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12161 }
12162 arg2 = (PLINT)(val2);
12163 {
12164 int res; void *buf = 0;
12165 Py_buffer view;
12166 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12167 if (res < 0) {
12168 PyErr_Clear();
12169 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem)""'");
12170 }
12171 buf = view.buf;
12172 PyBuffer_Release(&view);
12173 arg3 = (void *) buf;
12174 }
12175 plsmem(arg1,arg2,arg3);
12176 resultobj = SWIG_Py_Void();
12177 return resultobj;
12178fail:
12179 return NULL;
12180}
12181
12182
12183SWIGINTERN PyObject *_wrap_plsmema(PyObject *self, PyObject *args) {
12184 PyObject *resultobj = 0;
12185 PLINT arg1 ;
12186 PLINT arg2 ;
12187 void *arg3 = (void *) 0 ;
12188 int val1 ;
12189 int ecode1 = 0 ;
12190 int val2 ;
12191 int ecode2 = 0 ;
12192 PyObject *swig_obj[3] ;
12193
12194 if (!SWIG_Python_UnpackTuple(args, "plsmema", 3, 3, swig_obj)) SWIG_fail;
12195 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12196 if (!SWIG_IsOK(ecode1)) {
12197 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12198 }
12199 arg1 = (PLINT)(val1);
12200 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12201 if (!SWIG_IsOK(ecode2)) {
12202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12203 }
12204 arg2 = (PLINT)(val2);
12205 {
12206 int res; void *buf = 0;
12207 Py_buffer view;
12208 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12209 if (res < 0) {
12210 PyErr_Clear();
12211 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem)""'");
12212 }
12213 buf = view.buf;
12214 PyBuffer_Release(&view);
12215 arg3 = (void *) buf;
12216 }
12217 plsmema(arg1,arg2,arg3);
12218 resultobj = SWIG_Py_Void();
12219 return resultobj;
12220fail:
12221 return NULL;
12222}
12223
12224
12225SWIGINTERN PyObject *_wrap_plsmin(PyObject *self, PyObject *args) {
12226 PyObject *resultobj = 0;
12227 PLFLT arg1 ;
12228 PLFLT arg2 ;
12229 double val1 ;
12230 int ecode1 = 0 ;
12231 double val2 ;
12232 int ecode2 = 0 ;
12233 PyObject *swig_obj[2] ;
12234
12235 if (!SWIG_Python_UnpackTuple(args, "plsmin", 2, 2, swig_obj)) SWIG_fail;
12236 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12237 if (!SWIG_IsOK(ecode1)) {
12238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12239 }
12240 arg1 = (PLFLT)(val1);
12241 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12242 if (!SWIG_IsOK(ecode2)) {
12243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12244 }
12245 arg2 = (PLFLT)(val2);
12246 plsmin(arg1,arg2);
12247 resultobj = SWIG_Py_Void();
12248 return resultobj;
12249fail:
12250 return NULL;
12251}
12252
12253
12254SWIGINTERN PyObject *_wrap_plsori(PyObject *self, PyObject *args) {
12255 PyObject *resultobj = 0;
12256 PLINT arg1 ;
12257 int val1 ;
12258 int ecode1 = 0 ;
12259 PyObject *swig_obj[1] ;
12260
12261 if (!args) SWIG_fail;
12262 swig_obj[0] = args;
12263 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12264 if (!SWIG_IsOK(ecode1)) {
12265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12266 }
12267 arg1 = (PLINT)(val1);
12268 plsori(arg1);
12269 resultobj = SWIG_Py_Void();
12270 return resultobj;
12271fail:
12272 return NULL;
12273}
12274
12275
12276SWIGINTERN PyObject *_wrap_plspage(PyObject *self, PyObject *args) {
12277 PyObject *resultobj = 0;
12278 PLFLT arg1 ;
12279 PLFLT arg2 ;
12280 PLINT arg3 ;
12281 PLINT arg4 ;
12282 PLINT arg5 ;
12283 PLINT arg6 ;
12284 double val1 ;
12285 int ecode1 = 0 ;
12286 double val2 ;
12287 int ecode2 = 0 ;
12288 int val3 ;
12289 int ecode3 = 0 ;
12290 int val4 ;
12291 int ecode4 = 0 ;
12292 int val5 ;
12293 int ecode5 = 0 ;
12294 int val6 ;
12295 int ecode6 = 0 ;
12296 PyObject *swig_obj[6] ;
12297
12298 if (!SWIG_Python_UnpackTuple(args, "plspage", 6, 6, swig_obj)) SWIG_fail;
12299 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12300 if (!SWIG_IsOK(ecode1)) {
12301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12302 }
12303 arg1 = (PLFLT)(val1);
12304 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12305 if (!SWIG_IsOK(ecode2)) {
12306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12307 }
12308 arg2 = (PLFLT)(val2);
12309 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12310 if (!SWIG_IsOK(ecode3)) {
12311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12312 }
12313 arg3 = (PLINT)(val3);
12314 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
12315 if (!SWIG_IsOK(ecode4)) {
12316 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12317 }
12318 arg4 = (PLINT)(val4);
12319 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
12320 if (!SWIG_IsOK(ecode5)) {
12321 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12322 }
12323 arg5 = (PLINT)(val5);
12324 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
12325 if (!SWIG_IsOK(ecode6)) {
12326 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12327 }
12328 arg6 = (PLINT)(val6);
12329 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12330 resultobj = SWIG_Py_Void();
12331 return resultobj;
12332fail:
12333 return NULL;
12334}
12335
12336
12337SWIGINTERN PyObject *_wrap_plspal0(PyObject *self, PyObject *args) {
12338 PyObject *resultobj = 0;
12339 char *arg1 = (char *) 0 ;
12340 int res1 ;
12341 char *buf1 = 0 ;
12342 int alloc1 = 0 ;
12343 PyObject *swig_obj[1] ;
12344
12345 if (!args) SWIG_fail;
12346 swig_obj[0] = args;
12347 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12348 if (!SWIG_IsOK(res1)) {
12349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12350 }
12351 arg1 = (char *)(buf1);
12352 plspal0((char const *)arg1);
12353 resultobj = SWIG_Py_Void();
12354 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12355 return resultobj;
12356fail:
12357 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12358 return NULL;
12359}
12360
12361
12362SWIGINTERN PyObject *_wrap_plspal1(PyObject *self, PyObject *args) {
12363 PyObject *resultobj = 0;
12364 char *arg1 = (char *) 0 ;
12365 PLBOOL arg2 ;
12366 int res1 ;
12367 char *buf1 = 0 ;
12368 int alloc1 = 0 ;
12369 int val2 ;
12370 int ecode2 = 0 ;
12371 PyObject *swig_obj[2] ;
12372
12373 if (!SWIG_Python_UnpackTuple(args, "plspal1", 2, 2, swig_obj)) SWIG_fail;
12374 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12375 if (!SWIG_IsOK(res1)) {
12376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12377 }
12378 arg1 = (char *)(buf1);
12379 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12380 if (!SWIG_IsOK(ecode2)) {
12381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12382 }
12383 arg2 = (PLBOOL)(val2);
12384 plspal1((char const *)arg1,arg2);
12385 resultobj = SWIG_Py_Void();
12386 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12387 return resultobj;
12388fail:
12389 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12390 return NULL;
12391}
12392
12393
12394SWIGINTERN PyObject *_wrap_plspause(PyObject *self, PyObject *args) {
12395 PyObject *resultobj = 0;
12396 PLBOOL arg1 ;
12397 int val1 ;
12398 int ecode1 = 0 ;
12399 PyObject *swig_obj[1] ;
12400
12401 if (!args) SWIG_fail;
12402 swig_obj[0] = args;
12403 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12404 if (!SWIG_IsOK(ecode1)) {
12405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12406 }
12407 arg1 = (PLBOOL)(val1);
12408 plspause(arg1);
12409 resultobj = SWIG_Py_Void();
12410 return resultobj;
12411fail:
12412 return NULL;
12413}
12414
12415
12416SWIGINTERN PyObject *_wrap_plsstrm(PyObject *self, PyObject *args) {
12417 PyObject *resultobj = 0;
12418 PLINT arg1 ;
12419 int val1 ;
12420 int ecode1 = 0 ;
12421 PyObject *swig_obj[1] ;
12422
12423 if (!args) SWIG_fail;
12424 swig_obj[0] = args;
12425 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12426 if (!SWIG_IsOK(ecode1)) {
12427 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12428 }
12429 arg1 = (PLINT)(val1);
12430 plsstrm(arg1);
12431 resultobj = SWIG_Py_Void();
12432 return resultobj;
12433fail:
12434 return NULL;
12435}
12436
12437
12438SWIGINTERN PyObject *_wrap_plssub(PyObject *self, PyObject *args) {
12439 PyObject *resultobj = 0;
12440 PLINT arg1 ;
12441 PLINT arg2 ;
12442 int val1 ;
12443 int ecode1 = 0 ;
12444 int val2 ;
12445 int ecode2 = 0 ;
12446 PyObject *swig_obj[2] ;
12447
12448 if (!SWIG_Python_UnpackTuple(args, "plssub", 2, 2, swig_obj)) SWIG_fail;
12449 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12450 if (!SWIG_IsOK(ecode1)) {
12451 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12452 }
12453 arg1 = (PLINT)(val1);
12454 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12455 if (!SWIG_IsOK(ecode2)) {
12456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12457 }
12458 arg2 = (PLINT)(val2);
12459 plssub(arg1,arg2);
12460 resultobj = SWIG_Py_Void();
12461 return resultobj;
12462fail:
12463 return NULL;
12464}
12465
12466
12467SWIGINTERN PyObject *_wrap_plssym(PyObject *self, PyObject *args) {
12468 PyObject *resultobj = 0;
12469 PLFLT arg1 ;
12470 PLFLT arg2 ;
12471 double val1 ;
12472 int ecode1 = 0 ;
12473 double val2 ;
12474 int ecode2 = 0 ;
12475 PyObject *swig_obj[2] ;
12476
12477 if (!SWIG_Python_UnpackTuple(args, "plssym", 2, 2, swig_obj)) SWIG_fail;
12478 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12479 if (!SWIG_IsOK(ecode1)) {
12480 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12481 }
12482 arg1 = (PLFLT)(val1);
12483 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12484 if (!SWIG_IsOK(ecode2)) {
12485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12486 }
12487 arg2 = (PLFLT)(val2);
12488 plssym(arg1,arg2);
12489 resultobj = SWIG_Py_Void();
12490 return resultobj;
12491fail:
12492 return NULL;
12493}
12494
12495
12496SWIGINTERN PyObject *_wrap_plstar(PyObject *self, PyObject *args) {
12497 PyObject *resultobj = 0;
12498 PLINT arg1 ;
12499 PLINT arg2 ;
12500 int val1 ;
12501 int ecode1 = 0 ;
12502 int val2 ;
12503 int ecode2 = 0 ;
12504 PyObject *swig_obj[2] ;
12505
12506 if (!SWIG_Python_UnpackTuple(args, "plstar", 2, 2, swig_obj)) SWIG_fail;
12507 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12508 if (!SWIG_IsOK(ecode1)) {
12509 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12510 }
12511 arg1 = (PLINT)(val1);
12512 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12513 if (!SWIG_IsOK(ecode2)) {
12514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12515 }
12516 arg2 = (PLINT)(val2);
12517 plstar(arg1,arg2);
12518 resultobj = SWIG_Py_Void();
12519 return resultobj;
12520fail:
12521 return NULL;
12522}
12523
12524
12525SWIGINTERN PyObject *_wrap_plstart(PyObject *self, PyObject *args) {
12526 PyObject *resultobj = 0;
12527 char *arg1 = (char *) 0 ;
12528 PLINT arg2 ;
12529 PLINT arg3 ;
12530 int res1 ;
12531 char *buf1 = 0 ;
12532 int alloc1 = 0 ;
12533 int val2 ;
12534 int ecode2 = 0 ;
12535 int val3 ;
12536 int ecode3 = 0 ;
12537 PyObject *swig_obj[3] ;
12538
12539 if (!SWIG_Python_UnpackTuple(args, "plstart", 3, 3, swig_obj)) SWIG_fail;
12540 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12541 if (!SWIG_IsOK(res1)) {
12542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12543 }
12544 arg1 = (char *)(buf1);
12545 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12546 if (!SWIG_IsOK(ecode2)) {
12547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12548 }
12549 arg2 = (PLINT)(val2);
12550 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12551 if (!SWIG_IsOK(ecode3)) {
12552 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12553 }
12554 arg3 = (PLINT)(val3);
12555 plstart((char const *)arg1,arg2,arg3);
12556 resultobj = SWIG_Py_Void();
12557 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12558 return resultobj;
12559fail:
12560 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12561 return NULL;
12562}
12563
12564
12565SWIGINTERN PyObject *_wrap_plstransform(PyObject *self, PyObject *args) {
12566 PyObject *resultobj = 0;
12567 ct_func arg1 = (ct_func) 0 ;
12568 PLPointer arg2 = (PLPointer) 0 ;
12569 int res2 ;
12570 PyObject *swig_obj[2] ;
12571
12572 {
12573 python_ct = 0;
12574 arg1 = NULL;
12575 }
12576 if (!SWIG_Python_UnpackTuple(args, "plstransform", 0, 2, swig_obj)) SWIG_fail;
12577 if (swig_obj[0]) {
12578 {
12579 if ( python_ct )
12580 cleanup_ct();
12581 // it must be a callable or none
12582 if ( swig_obj[0] == Py_None )
12583 {
12584 arg1 = NULL;
12585 }
12586 else
12587 {
12588 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12589 {
12590 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12591 return NULL;
12592 }
12593 arg1 = marshal_ct( swig_obj[0] );
12594 }
12595 }
12596 }
12597 if (swig_obj[1]) {
12598 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12599 if (!SWIG_IsOK(res2)) {
12600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12601 }
12602 }
12603 plstransform(arg1,arg2);
12604 resultobj = SWIG_Py_Void();
12605 return resultobj;
12606fail:
12607 return NULL;
12608}
12609
12610
12611SWIGINTERN PyObject *_wrap_plstring(PyObject *self, PyObject *args) {
12612 PyObject *resultobj = 0;
12613 PLINT arg1 ;
12614 PLFLT *arg2 = (PLFLT *) 0 ;
12615 PLFLT *arg3 = (PLFLT *) 0 ;
12616 char *arg4 = (char *) 0 ;
12617 PyArrayObject *tmp1 = NULL ;
12618 PyArrayObject *tmp3 = NULL ;
12619 int res4 ;
12620 char *buf4 = 0 ;
12621 int alloc4 = 0 ;
12622 PyObject *swig_obj[3] ;
12623
12624 if (!SWIG_Python_UnpackTuple(args, "plstring", 3, 3, swig_obj)) SWIG_fail;
12625 {
12626 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12627 if ( tmp1 == NULL )
12628 return NULL;
12629 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12630 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12631 }
12632 {
12633 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12634 if ( tmp3 == NULL )
12635 return NULL;
12636 if ( PyArray_DIMS( tmp3 )[0] != Alen )
12637 {
12638 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12639 return NULL;
12640 }
12641 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12642 }
12643 res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
12644 if (!SWIG_IsOK(res4)) {
12645 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
12646 }
12647 arg4 = (char *)(buf4);
12648 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
12649 resultobj = SWIG_Py_Void();
12650 {
12651 Py_CLEAR( tmp1 );
12652 }
12653 {
12654 Py_CLEAR( tmp3 );
12655 }
12656 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12657 return resultobj;
12658fail:
12659 {
12660 Py_CLEAR( tmp1 );
12661 }
12662 {
12663 Py_CLEAR( tmp3 );
12664 }
12665 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
12666 return NULL;
12667}
12668
12669
12670SWIGINTERN PyObject *_wrap_plstring3(PyObject *self, PyObject *args) {
12671 PyObject *resultobj = 0;
12672 PLINT arg1 ;
12673 PLFLT *arg2 = (PLFLT *) 0 ;
12674 PLFLT *arg3 = (PLFLT *) 0 ;
12675 PLFLT *arg4 = (PLFLT *) 0 ;
12676 char *arg5 = (char *) 0 ;
12677 PyArrayObject *tmp1 = NULL ;
12678 PyArrayObject *tmp3 = NULL ;
12679 PyArrayObject *tmp4 = NULL ;
12680 int res5 ;
12681 char *buf5 = 0 ;
12682 int alloc5 = 0 ;
12683 PyObject *swig_obj[4] ;
12684
12685 if (!SWIG_Python_UnpackTuple(args, "plstring3", 4, 4, swig_obj)) SWIG_fail;
12686 {
12687 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
12688 if ( tmp1 == NULL )
12689 return NULL;
12690 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
12691 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
12692 }
12693 {
12694 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
12695 if ( tmp3 == NULL )
12696 return NULL;
12697 if ( PyArray_DIMS( tmp3 )[0] != Alen )
12698 {
12699 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12700 return NULL;
12701 }
12702 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
12703 }
12704 {
12705 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
12706 if ( tmp4 == NULL )
12707 return NULL;
12708 if ( PyArray_DIMS( tmp4 )[0] != Alen )
12709 {
12710 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12711 return NULL;
12712 }
12713 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
12714 }
12715 res5 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf5, NULL, &alloc5);
12716 if (!SWIG_IsOK(res5)) {
12717 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
12718 }
12719 arg5 = (char *)(buf5);
12720 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
12721 resultobj = SWIG_Py_Void();
12722 {
12723 Py_CLEAR( tmp1 );
12724 }
12725 {
12726 Py_CLEAR( tmp3 );
12727 }
12728 {
12729 Py_CLEAR( tmp4 );
12730 }
12731 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12732 return resultobj;
12733fail:
12734 {
12735 Py_CLEAR( tmp1 );
12736 }
12737 {
12738 Py_CLEAR( tmp3 );
12739 }
12740 {
12741 Py_CLEAR( tmp4 );
12742 }
12743 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
12744 return NULL;
12745}
12746
12747
12748SWIGINTERN PyObject *_wrap_plstripa(PyObject *self, PyObject *args) {
12749 PyObject *resultobj = 0;
12750 PLINT arg1 ;
12751 PLINT arg2 ;
12752 PLFLT arg3 ;
12753 PLFLT arg4 ;
12754 int val1 ;
12755 int ecode1 = 0 ;
12756 int val2 ;
12757 int ecode2 = 0 ;
12758 double val3 ;
12759 int ecode3 = 0 ;
12760 double val4 ;
12761 int ecode4 = 0 ;
12762 PyObject *swig_obj[4] ;
12763
12764 if (!SWIG_Python_UnpackTuple(args, "plstripa", 4, 4, swig_obj)) SWIG_fail;
12765 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12766 if (!SWIG_IsOK(ecode1)) {
12767 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
12768 }
12769 arg1 = (PLINT)(val1);
12770 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12771 if (!SWIG_IsOK(ecode2)) {
12772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
12773 }
12774 arg2 = (PLINT)(val2);
12775 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
12776 if (!SWIG_IsOK(ecode3)) {
12777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
12778 }
12779 arg3 = (PLFLT)(val3);
12780 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
12781 if (!SWIG_IsOK(ecode4)) {
12782 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
12783 }
12784 arg4 = (PLFLT)(val4);
12785 plstripa(arg1,arg2,arg3,arg4);
12786 resultobj = SWIG_Py_Void();
12787 return resultobj;
12788fail:
12789 return NULL;
12790}
12791
12792
12793SWIGINTERN PyObject *_wrap_plstripc(PyObject *self, PyObject *args) {
12794 PyObject *resultobj = 0;
12795 PLINT *arg1 = (PLINT *) 0 ;
12796 char *arg2 = (char *) 0 ;
12797 char *arg3 = (char *) 0 ;
12798 PLFLT arg4 ;
12799 PLFLT arg5 ;
12800 PLFLT arg6 ;
12801 PLFLT arg7 ;
12802 PLFLT arg8 ;
12803 PLFLT arg9 ;
12804 PLFLT arg10 ;
12805 PLBOOL arg11 ;
12806 PLBOOL arg12 ;
12807 PLINT arg13 ;
12808 PLINT arg14 ;
12809 PLINT *arg15 = (PLINT *) 0 ;
12810 PLINT *arg16 = (PLINT *) 0 ;
12811 char **arg17 ;
12812 char *arg18 = (char *) 0 ;
12813 char *arg19 = (char *) 0 ;
12814 char *arg20 = (char *) 0 ;
12815 PLINT temp1 ;
12816 int res1 = SWIG_TMPOBJ ;
12817 int res2 ;
12818 char *buf2 = 0 ;
12819 int alloc2 = 0 ;
12820 int res3 ;
12821 char *buf3 = 0 ;
12822 int alloc3 = 0 ;
12823 double val4 ;
12824 int ecode4 = 0 ;
12825 double val5 ;
12826 int ecode5 = 0 ;
12827 double val6 ;
12828 int ecode6 = 0 ;
12829 double val7 ;
12830 int ecode7 = 0 ;
12831 double val8 ;
12832 int ecode8 = 0 ;
12833 double val9 ;
12834 int ecode9 = 0 ;
12835 double val10 ;
12836 int ecode10 = 0 ;
12837 int val11 ;
12838 int ecode11 = 0 ;
12839 int val12 ;
12840 int ecode12 = 0 ;
12841 int val13 ;
12842 int ecode13 = 0 ;
12843 int val14 ;
12844 int ecode14 = 0 ;
12845 PyArrayObject *tmp15 = NULL ;
12846 PyArrayObject *tmp16 = NULL ;
12847 char **tmp17 = NULL ;
12848 int res18 ;
12849 char *buf18 = 0 ;
12850 int alloc18 = 0 ;
12851 int res19 ;
12852 char *buf19 = 0 ;
12853 int alloc19 = 0 ;
12854 int res20 ;
12855 char *buf20 = 0 ;
12856 int alloc20 = 0 ;
12857 PyObject *swig_obj[19] ;
12858
12859 arg1 = &temp1;
12860 if (!SWIG_Python_UnpackTuple(args, "plstripc", 19, 19, swig_obj)) SWIG_fail;
12861 res2 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf2, NULL, &alloc2);
12862 if (!SWIG_IsOK(res2)) {
12863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
12864 }
12865 arg2 = (char *)(buf2);
12866 res3 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf3, NULL, &alloc3);
12867 if (!SWIG_IsOK(res3)) {
12868 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
12869 }
12870 arg3 = (char *)(buf3);
12871 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
12872 if (!SWIG_IsOK(ecode4)) {
12873 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
12874 }
12875 arg4 = (PLFLT)(val4);
12876 ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
12877 if (!SWIG_IsOK(ecode5)) {
12878 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
12879 }
12880 arg5 = (PLFLT)(val5);
12881 ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
12882 if (!SWIG_IsOK(ecode6)) {
12883 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
12884 }
12885 arg6 = (PLFLT)(val6);
12886 ecode7 = SWIG_AsVal_double(swig_obj[5], &val7);
12887 if (!SWIG_IsOK(ecode7)) {
12888 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
12889 }
12890 arg7 = (PLFLT)(val7);
12891 ecode8 = SWIG_AsVal_double(swig_obj[6], &val8);
12892 if (!SWIG_IsOK(ecode8)) {
12893 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
12894 }
12895 arg8 = (PLFLT)(val8);
12896 ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
12897 if (!SWIG_IsOK(ecode9)) {
12898 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
12899 }
12900 arg9 = (PLFLT)(val9);
12901 ecode10 = SWIG_AsVal_double(swig_obj[8], &val10);
12902 if (!SWIG_IsOK(ecode10)) {
12903 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
12904 }
12905 arg10 = (PLFLT)(val10);
12906 ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
12907 if (!SWIG_IsOK(ecode11)) {
12908 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
12909 }
12910 arg11 = (PLBOOL)(val11);
12911 ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
12912 if (!SWIG_IsOK(ecode12)) {
12913 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
12914 }
12915 arg12 = (PLBOOL)(val12);
12916 ecode13 = SWIG_AsVal_int(swig_obj[11], &val13);
12917 if (!SWIG_IsOK(ecode13)) {
12918 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
12919 }
12920 arg13 = (PLINT)(val13);
12921 ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
12922 if (!SWIG_IsOK(ecode14)) {
12923 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
12924 }
12925 arg14 = (PLINT)(val14);
12926 {
12927 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
12928 if ( tmp15 == NULL )
12929 return NULL;
12930 Alen = PyArray_DIMS( tmp15 )[0];
12931 arg15 = (PLINT *) PyArray_DATA( tmp15 );
12932 }
12933 {
12934 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[14], NPY_PLINT, 1, 1 );
12935 if ( tmp16 == NULL )
12936 return NULL;
12937 if ( PyArray_DIMS( tmp16 )[0] != Alen )
12938 {
12939 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
12940 return NULL;
12941 }
12942 arg16 = (PLINT *) PyArray_DATA( tmp16 );
12943 }
12944 {
12945 int i;
12946 PyObject *elt, *unicode_string;
12947
12948 if ( !PySequence_Check( swig_obj[15] ) || PySequence_Size( swig_obj[15] ) != 4 )
12949 {
12950 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
12951 return NULL;
12952 }
12953 if ( Alen != 4 )
12954 {
12955 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
12956 return NULL;
12957 }
12958 tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
12959 if ( tmp17 == NULL )
12960 return NULL;
12961 arg17 = tmp17;
12962 for ( i = 0; i < 4; i++ )
12963 {
12964 arg17[i] = NULL;
12965 elt = PySequence_Fast_GET_ITEM( swig_obj[15], i );
12966 if ( PyString_Check( elt ) )
12967 {
12968 arg17[i] = PyString_AsString( elt );
12969 }
12970 else if ( PyUnicode_Check( elt ) )
12971 {
12972 unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
12973 arg17[i] = PyBytes_AS_STRING( unicode_string );
12974 }
12975 if ( arg17[i] == NULL )
12976 {
12977 free( tmp17 );
12978 return NULL;
12979 }
12980 }
12981 }
12982 res18 = SWIG_AsCharPtrAndSize(swig_obj[16], &buf18, NULL, &alloc18);
12983 if (!SWIG_IsOK(res18)) {
12984 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
12985 }
12986 arg18 = (char *)(buf18);
12987 res19 = SWIG_AsCharPtrAndSize(swig_obj[17], &buf19, NULL, &alloc19);
12988 if (!SWIG_IsOK(res19)) {
12989 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
12990 }
12991 arg19 = (char *)(buf19);
12992 res20 = SWIG_AsCharPtrAndSize(swig_obj[18], &buf20, NULL, &alloc20);
12993 if (!SWIG_IsOK(res20)) {
12994 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
12995 }
12996 arg20 = (char *)(buf20);
12997 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);
12998 resultobj = SWIG_Py_Void();
12999 if (SWIG_IsTmpObj(res1)) {
13000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13001 } else {
13002 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13004 }
13005 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13006 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13007 {
13008 Py_CLEAR( tmp15 );
13009 }
13010 {
13011 Py_CLEAR( tmp16 );
13012 }
13013 {
13014 free( tmp17 );
13015 }
13016 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13017 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13018 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13019 return resultobj;
13020fail:
13021 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13022 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13023 {
13024 Py_CLEAR( tmp15 );
13025 }
13026 {
13027 Py_CLEAR( tmp16 );
13028 }
13029 {
13030 free( tmp17 );
13031 }
13032 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13033 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13034 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13035 return NULL;
13036}
13037
13038
13039SWIGINTERN PyObject *_wrap_plstripd(PyObject *self, PyObject *args) {
13040 PyObject *resultobj = 0;
13041 PLINT arg1 ;
13042 int val1 ;
13043 int ecode1 = 0 ;
13044 PyObject *swig_obj[1] ;
13045
13046 if (!args) SWIG_fail;
13047 swig_obj[0] = args;
13048 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13049 if (!SWIG_IsOK(ecode1)) {
13050 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13051 }
13052 arg1 = (PLINT)(val1);
13053 plstripd(arg1);
13054 resultobj = SWIG_Py_Void();
13055 return resultobj;
13056fail:
13057 return NULL;
13058}
13059
13060
13061SWIGINTERN PyObject *_wrap_plstyl(PyObject *self, PyObject *args) {
13062 PyObject *resultobj = 0;
13063 PLINT arg1 ;
13064 PLINT *arg2 = (PLINT *) 0 ;
13065 PLINT *arg3 = (PLINT *) 0 ;
13066 PyArrayObject *tmp1 = NULL ;
13067 PyArrayObject *tmp3 = NULL ;
13068 PyObject *swig_obj[2] ;
13069
13070 if (!SWIG_Python_UnpackTuple(args, "plstyl", 2, 2, swig_obj)) SWIG_fail;
13071 {
13072 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
13073 if ( tmp1 == NULL )
13074 return NULL;
13075 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13076 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13077 }
13078 {
13079 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
13080 if ( tmp3 == NULL )
13081 return NULL;
13082 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13083 {
13084 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13085 return NULL;
13086 }
13087 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13088 }
13089 plstyl(arg1,(int const *)arg2,(int const *)arg3);
13090 resultobj = SWIG_Py_Void();
13091 {
13092 Py_CLEAR( tmp1 );
13093 }
13094 {
13095 Py_CLEAR( tmp3 );
13096 }
13097 return resultobj;
13098fail:
13099 {
13100 Py_CLEAR( tmp1 );
13101 }
13102 {
13103 Py_CLEAR( tmp3 );
13104 }
13105 return NULL;
13106}
13107
13108
13109SWIGINTERN PyObject *_wrap_plsvect(PyObject *self, PyObject *args) {
13110 PyObject *resultobj = 0;
13111 PLFLT *arg1 = (PLFLT *) 0 ;
13112 PLFLT *arg2 = (PLFLT *) 0 ;
13113 PLINT arg3 ;
13114 PLBOOL arg4 ;
13115 PyArrayObject *tmp1 = NULL ;
13116 PyArrayObject *tmp2 = NULL ;
13117 int val4 ;
13118 int ecode4 = 0 ;
13119 PyObject *swig_obj[3] ;
13120
13121 if (!SWIG_Python_UnpackTuple(args, "plsvect", 3, 3, swig_obj)) SWIG_fail;
13122 {
13123 if ( swig_obj[0] != Py_None )
13124 {
13125 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13126 if ( tmp1 == NULL )
13127 return NULL;
13128 Alen = PyArray_DIMS( tmp1 )[0];
13129 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13130 }
13131 else
13132 {
13133 arg1 = NULL;
13134 Alen = 0;
13135 }
13136 }
13137 {
13138 if ( swig_obj[1] != Py_None )
13139 {
13140 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13141 if ( tmp2 == NULL )
13142 return NULL;
13143 if ( PyArray_DIMS( tmp2 )[0] != Alen )
13144 {
13145 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13146 return NULL;
13147 }
13148 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13149 arg3 = PyArray_DIMS( tmp2 )[0];
13150 }
13151 else
13152 {
13153 arg2 = NULL;
13154 arg3 = 0;
13155 }
13156 }
13157 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13158 if (!SWIG_IsOK(ecode4)) {
13159 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13160 }
13161 arg4 = (PLBOOL)(val4);
13162 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13163 resultobj = SWIG_Py_Void();
13164 {
13165 Py_CLEAR( tmp1 );
13166 }
13167 {
13168 Py_CLEAR( tmp2 );
13169 }
13170 return resultobj;
13171fail:
13172 {
13173 Py_CLEAR( tmp1 );
13174 }
13175 {
13176 Py_CLEAR( tmp2 );
13177 }
13178 return NULL;
13179}
13180
13181
13182SWIGINTERN PyObject *_wrap_plsvpa(PyObject *self, PyObject *args) {
13183 PyObject *resultobj = 0;
13184 PLFLT arg1 ;
13185 PLFLT arg2 ;
13186 PLFLT arg3 ;
13187 PLFLT arg4 ;
13188 double val1 ;
13189 int ecode1 = 0 ;
13190 double val2 ;
13191 int ecode2 = 0 ;
13192 double val3 ;
13193 int ecode3 = 0 ;
13194 double val4 ;
13195 int ecode4 = 0 ;
13196 PyObject *swig_obj[4] ;
13197
13198 if (!SWIG_Python_UnpackTuple(args, "plsvpa", 4, 4, swig_obj)) SWIG_fail;
13199 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13200 if (!SWIG_IsOK(ecode1)) {
13201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13202 }
13203 arg1 = (PLFLT)(val1);
13204 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13205 if (!SWIG_IsOK(ecode2)) {
13206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13207 }
13208 arg2 = (PLFLT)(val2);
13209 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13210 if (!SWIG_IsOK(ecode3)) {
13211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13212 }
13213 arg3 = (PLFLT)(val3);
13214 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13215 if (!SWIG_IsOK(ecode4)) {
13216 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13217 }
13218 arg4 = (PLFLT)(val4);
13219 plsvpa(arg1,arg2,arg3,arg4);
13220 resultobj = SWIG_Py_Void();
13221 return resultobj;
13222fail:
13223 return NULL;
13224}
13225
13226
13227SWIGINTERN PyObject *_wrap_plsxax(PyObject *self, PyObject *args) {
13228 PyObject *resultobj = 0;
13229 PLINT arg1 ;
13230 PLINT arg2 ;
13231 int val1 ;
13232 int ecode1 = 0 ;
13233 int val2 ;
13234 int ecode2 = 0 ;
13235 PyObject *swig_obj[2] ;
13236
13237 if (!SWIG_Python_UnpackTuple(args, "plsxax", 2, 2, swig_obj)) SWIG_fail;
13238 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13239 if (!SWIG_IsOK(ecode1)) {
13240 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13241 }
13242 arg1 = (PLINT)(val1);
13243 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13244 if (!SWIG_IsOK(ecode2)) {
13245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13246 }
13247 arg2 = (PLINT)(val2);
13248 plsxax(arg1,arg2);
13249 resultobj = SWIG_Py_Void();
13250 return resultobj;
13251fail:
13252 return NULL;
13253}
13254
13255
13256SWIGINTERN PyObject *_wrap_plsyax(PyObject *self, PyObject *args) {
13257 PyObject *resultobj = 0;
13258 PLINT arg1 ;
13259 PLINT arg2 ;
13260 int val1 ;
13261 int ecode1 = 0 ;
13262 int val2 ;
13263 int ecode2 = 0 ;
13264 PyObject *swig_obj[2] ;
13265
13266 if (!SWIG_Python_UnpackTuple(args, "plsyax", 2, 2, swig_obj)) SWIG_fail;
13267 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13268 if (!SWIG_IsOK(ecode1)) {
13269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13270 }
13271 arg1 = (PLINT)(val1);
13272 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13273 if (!SWIG_IsOK(ecode2)) {
13274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13275 }
13276 arg2 = (PLINT)(val2);
13277 plsyax(arg1,arg2);
13278 resultobj = SWIG_Py_Void();
13279 return resultobj;
13280fail:
13281 return NULL;
13282}
13283
13284
13285SWIGINTERN PyObject *_wrap_plsym(PyObject *self, PyObject *args) {
13286 PyObject *resultobj = 0;
13287 PLINT arg1 ;
13288 PLFLT *arg2 = (PLFLT *) 0 ;
13289 PLFLT *arg3 = (PLFLT *) 0 ;
13290 PLINT arg4 ;
13291 PyArrayObject *tmp1 = NULL ;
13292 PyArrayObject *tmp3 = NULL ;
13293 int val4 ;
13294 int ecode4 = 0 ;
13295 PyObject *swig_obj[3] ;
13296
13297 if (!SWIG_Python_UnpackTuple(args, "plsym", 3, 3, swig_obj)) SWIG_fail;
13298 {
13299 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13300 if ( tmp1 == NULL )
13301 return NULL;
13302 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13303 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13304 }
13305 {
13306 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13307 if ( tmp3 == NULL )
13308 return NULL;
13309 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13310 {
13311 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13312 return NULL;
13313 }
13314 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13315 }
13316 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13317 if (!SWIG_IsOK(ecode4)) {
13318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13319 }
13320 arg4 = (PLINT)(val4);
13321 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13322 resultobj = SWIG_Py_Void();
13323 {
13324 Py_CLEAR( tmp1 );
13325 }
13326 {
13327 Py_CLEAR( tmp3 );
13328 }
13329 return resultobj;
13330fail:
13331 {
13332 Py_CLEAR( tmp1 );
13333 }
13334 {
13335 Py_CLEAR( tmp3 );
13336 }
13337 return NULL;
13338}
13339
13340
13341SWIGINTERN PyObject *_wrap_plszax(PyObject *self, PyObject *args) {
13342 PyObject *resultobj = 0;
13343 PLINT arg1 ;
13344 PLINT arg2 ;
13345 int val1 ;
13346 int ecode1 = 0 ;
13347 int val2 ;
13348 int ecode2 = 0 ;
13349 PyObject *swig_obj[2] ;
13350
13351 if (!SWIG_Python_UnpackTuple(args, "plszax", 2, 2, swig_obj)) SWIG_fail;
13352 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13353 if (!SWIG_IsOK(ecode1)) {
13354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13355 }
13356 arg1 = (PLINT)(val1);
13357 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13358 if (!SWIG_IsOK(ecode2)) {
13359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13360 }
13361 arg2 = (PLINT)(val2);
13362 plszax(arg1,arg2);
13363 resultobj = SWIG_Py_Void();
13364 return resultobj;
13365fail:
13366 return NULL;
13367}
13368
13369
13370SWIGINTERN PyObject *_wrap_pltext(PyObject *self, PyObject *args) {
13371 PyObject *resultobj = 0;
13372
13373 if (!SWIG_Python_UnpackTuple(args, "pltext", 0, 0, 0)) SWIG_fail;
13374 pltext();
13375 resultobj = SWIG_Py_Void();
13376 return resultobj;
13377fail:
13378 return NULL;
13379}
13380
13381
13382SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *self, PyObject *args) {
13383 PyObject *resultobj = 0;
13384 char *arg1 = (char *) 0 ;
13385 int res1 ;
13386 char *buf1 = 0 ;
13387 int alloc1 = 0 ;
13388 PyObject *swig_obj[1] ;
13389
13390 if (!args) SWIG_fail;
13391 swig_obj[0] = args;
13392 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13393 if (!SWIG_IsOK(res1)) {
13394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13395 }
13396 arg1 = (char *)(buf1);
13397 pltimefmt((char const *)arg1);
13398 resultobj = SWIG_Py_Void();
13399 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13400 return resultobj;
13401fail:
13402 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13403 return NULL;
13404}
13405
13406
13407SWIGINTERN PyObject *_wrap_plvasp(PyObject *self, PyObject *args) {
13408 PyObject *resultobj = 0;
13409 PLFLT arg1 ;
13410 double val1 ;
13411 int ecode1 = 0 ;
13412 PyObject *swig_obj[1] ;
13413
13414 if (!args) SWIG_fail;
13415 swig_obj[0] = args;
13416 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13417 if (!SWIG_IsOK(ecode1)) {
13418 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13419 }
13420 arg1 = (PLFLT)(val1);
13421 plvasp(arg1);
13422 resultobj = SWIG_Py_Void();
13423 return resultobj;
13424fail:
13425 return NULL;
13426}
13427
13428
13429SWIGINTERN PyObject *_wrap_plvect(PyObject *self, PyObject *args) {
13430 PyObject *resultobj = 0;
13431 PLFLT **arg1 = (PLFLT **) 0 ;
13432 PLFLT **arg2 = (PLFLT **) 0 ;
13433 PLINT arg3 ;
13434 PLINT arg4 ;
13435 PLFLT arg5 ;
13436 pltr_func arg6 = (pltr_func) 0 ;
13437 PLPointer arg7 = (PLPointer) 0 ;
13438 PyArrayObject *tmp1 = NULL ;
13439 PyArrayObject *tmp2 = NULL ;
13440 double val5 ;
13441 int ecode5 = 0 ;
13442 PyObject *swig_obj[5] ;
13443
13444 {
13445 python_pltr = 0;
13446 arg6 = NULL;
13447 }
13448 {
13449 arg7 = NULL;
13450 }
13451 if (!SWIG_Python_UnpackTuple(args, "plvect", 3, 5, swig_obj)) SWIG_fail;
13452 {
13453 int i, size;
13454 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
13455 if ( tmp1 == NULL )
13456 return NULL;
13457 Xlen = PyArray_DIMS( tmp1 )[0];
13458 Ylen = PyArray_DIMS( tmp1 )[1];
13459 size = Ylen;
13460 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13461 for ( i = 0; i < Xlen; i++ )
13462 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13463 }
13464 {
13465 int i, size;
13466 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 2, 2 );
13467 if ( tmp2 == NULL )
13468 return NULL;
13469 if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13470 {
13471 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13472 return NULL;
13473 }
13474 arg3 = PyArray_DIMS( tmp2 )[0];
13475 arg4 = PyArray_DIMS( tmp2 )[1];
13476 size = arg4;
13477 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13478 for ( i = 0; i < arg3; i++ )
13479 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13480 }
13481 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
13482 if (!SWIG_IsOK(ecode5)) {
13483 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13484 }
13485 arg5 = (PLFLT)(val5);
13486 if (swig_obj[3]) {
13487 {
13488 // it must be a callable or None
13489 if ( swig_obj[3] == Py_None )
13490 {
13491 arg6 = NULL;
13492 }
13493 else
13494 {
13495 if ( !PyCallable_Check( (PyObject *) swig_obj[3] ) )
13496 {
13497 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13498 return NULL;
13499 }
13500 arg6 = marshal_pltr( swig_obj[3] );
13501 }
13502 }
13503 }
13504 if (swig_obj[4]) {
13505 {
13506 if ( swig_obj[4] == Py_None )
13507 arg7 = NULL;
13508 else
13509 {
13510 arg7 = marshal_PLPointer( swig_obj[4], 0 );
13511 }
13512 }
13513 }
13514 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13515 resultobj = SWIG_Py_Void();
13516 {
13517 Py_CLEAR( tmp1 );
13518 free( arg1 );
13519 }
13520 {
13521 Py_CLEAR( tmp2 );
13522 free( arg2 );
13523 }
13524 {
13525 cleanup_pltr();
13526 }
13527 {
13529 }
13530 return resultobj;
13531fail:
13532 {
13533 Py_CLEAR( tmp1 );
13534 free( arg1 );
13535 }
13536 {
13537 Py_CLEAR( tmp2 );
13538 free( arg2 );
13539 }
13540 {
13541 cleanup_pltr();
13542 }
13543 {
13545 }
13546 return NULL;
13547}
13548
13549
13550SWIGINTERN PyObject *_wrap_plvpas(PyObject *self, PyObject *args) {
13551 PyObject *resultobj = 0;
13552 PLFLT arg1 ;
13553 PLFLT arg2 ;
13554 PLFLT arg3 ;
13555 PLFLT arg4 ;
13556 PLFLT arg5 ;
13557 double val1 ;
13558 int ecode1 = 0 ;
13559 double val2 ;
13560 int ecode2 = 0 ;
13561 double val3 ;
13562 int ecode3 = 0 ;
13563 double val4 ;
13564 int ecode4 = 0 ;
13565 double val5 ;
13566 int ecode5 = 0 ;
13567 PyObject *swig_obj[5] ;
13568
13569 if (!SWIG_Python_UnpackTuple(args, "plvpas", 5, 5, swig_obj)) SWIG_fail;
13570 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13571 if (!SWIG_IsOK(ecode1)) {
13572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13573 }
13574 arg1 = (PLFLT)(val1);
13575 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13576 if (!SWIG_IsOK(ecode2)) {
13577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13578 }
13579 arg2 = (PLFLT)(val2);
13580 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13581 if (!SWIG_IsOK(ecode3)) {
13582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13583 }
13584 arg3 = (PLFLT)(val3);
13585 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13586 if (!SWIG_IsOK(ecode4)) {
13587 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13588 }
13589 arg4 = (PLFLT)(val4);
13590 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13591 if (!SWIG_IsOK(ecode5)) {
13592 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13593 }
13594 arg5 = (PLFLT)(val5);
13595 plvpas(arg1,arg2,arg3,arg4,arg5);
13596 resultobj = SWIG_Py_Void();
13597 return resultobj;
13598fail:
13599 return NULL;
13600}
13601
13602
13603SWIGINTERN PyObject *_wrap_plvpor(PyObject *self, PyObject *args) {
13604 PyObject *resultobj = 0;
13605 PLFLT arg1 ;
13606 PLFLT arg2 ;
13607 PLFLT arg3 ;
13608 PLFLT arg4 ;
13609 double val1 ;
13610 int ecode1 = 0 ;
13611 double val2 ;
13612 int ecode2 = 0 ;
13613 double val3 ;
13614 int ecode3 = 0 ;
13615 double val4 ;
13616 int ecode4 = 0 ;
13617 PyObject *swig_obj[4] ;
13618
13619 if (!SWIG_Python_UnpackTuple(args, "plvpor", 4, 4, swig_obj)) SWIG_fail;
13620 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13621 if (!SWIG_IsOK(ecode1)) {
13622 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
13623 }
13624 arg1 = (PLFLT)(val1);
13625 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13626 if (!SWIG_IsOK(ecode2)) {
13627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
13628 }
13629 arg2 = (PLFLT)(val2);
13630 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13631 if (!SWIG_IsOK(ecode3)) {
13632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
13633 }
13634 arg3 = (PLFLT)(val3);
13635 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13636 if (!SWIG_IsOK(ecode4)) {
13637 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
13638 }
13639 arg4 = (PLFLT)(val4);
13640 plvpor(arg1,arg2,arg3,arg4);
13641 resultobj = SWIG_Py_Void();
13642 return resultobj;
13643fail:
13644 return NULL;
13645}
13646
13647
13648SWIGINTERN PyObject *_wrap_plvsta(PyObject *self, PyObject *args) {
13649 PyObject *resultobj = 0;
13650
13651 if (!SWIG_Python_UnpackTuple(args, "plvsta", 0, 0, 0)) SWIG_fail;
13652 plvsta();
13653 resultobj = SWIG_Py_Void();
13654 return resultobj;
13655fail:
13656 return NULL;
13657}
13658
13659
13660SWIGINTERN PyObject *_wrap_plw3d(PyObject *self, PyObject *args) {
13661 PyObject *resultobj = 0;
13662 PLFLT arg1 ;
13663 PLFLT arg2 ;
13664 PLFLT arg3 ;
13665 PLFLT arg4 ;
13666 PLFLT arg5 ;
13667 PLFLT arg6 ;
13668 PLFLT arg7 ;
13669 PLFLT arg8 ;
13670 PLFLT arg9 ;
13671 PLFLT arg10 ;
13672 PLFLT arg11 ;
13673 double val1 ;
13674 int ecode1 = 0 ;
13675 double val2 ;
13676 int ecode2 = 0 ;
13677 double val3 ;
13678 int ecode3 = 0 ;
13679 double val4 ;
13680 int ecode4 = 0 ;
13681 double val5 ;
13682 int ecode5 = 0 ;
13683 double val6 ;
13684 int ecode6 = 0 ;
13685 double val7 ;
13686 int ecode7 = 0 ;
13687 double val8 ;
13688 int ecode8 = 0 ;
13689 double val9 ;
13690 int ecode9 = 0 ;
13691 double val10 ;
13692 int ecode10 = 0 ;
13693 double val11 ;
13694 int ecode11 = 0 ;
13695 PyObject *swig_obj[11] ;
13696
13697 if (!SWIG_Python_UnpackTuple(args, "plw3d", 11, 11, swig_obj)) SWIG_fail;
13698 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13699 if (!SWIG_IsOK(ecode1)) {
13700 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
13701 }
13702 arg1 = (PLFLT)(val1);
13703 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13704 if (!SWIG_IsOK(ecode2)) {
13705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
13706 }
13707 arg2 = (PLFLT)(val2);
13708 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13709 if (!SWIG_IsOK(ecode3)) {
13710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
13711 }
13712 arg3 = (PLFLT)(val3);
13713 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13714 if (!SWIG_IsOK(ecode4)) {
13715 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
13716 }
13717 arg4 = (PLFLT)(val4);
13718 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13719 if (!SWIG_IsOK(ecode5)) {
13720 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
13721 }
13722 arg5 = (PLFLT)(val5);
13723 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13724 if (!SWIG_IsOK(ecode6)) {
13725 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
13726 }
13727 arg6 = (PLFLT)(val6);
13728 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
13729 if (!SWIG_IsOK(ecode7)) {
13730 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
13731 }
13732 arg7 = (PLFLT)(val7);
13733 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
13734 if (!SWIG_IsOK(ecode8)) {
13735 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
13736 }
13737 arg8 = (PLFLT)(val8);
13738 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
13739 if (!SWIG_IsOK(ecode9)) {
13740 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
13741 }
13742 arg9 = (PLFLT)(val9);
13743 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
13744 if (!SWIG_IsOK(ecode10)) {
13745 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
13746 }
13747 arg10 = (PLFLT)(val10);
13748 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
13749 if (!SWIG_IsOK(ecode11)) {
13750 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
13751 }
13752 arg11 = (PLFLT)(val11);
13753 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13754 resultobj = SWIG_Py_Void();
13755 return resultobj;
13756fail:
13757 return NULL;
13758}
13759
13760
13761SWIGINTERN PyObject *_wrap_plwidth(PyObject *self, PyObject *args) {
13762 PyObject *resultobj = 0;
13763 PLFLT arg1 ;
13764 double val1 ;
13765 int ecode1 = 0 ;
13766 PyObject *swig_obj[1] ;
13767
13768 if (!args) SWIG_fail;
13769 swig_obj[0] = args;
13770 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13771 if (!SWIG_IsOK(ecode1)) {
13772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
13773 }
13774 arg1 = (PLFLT)(val1);
13775 plwidth(arg1);
13776 resultobj = SWIG_Py_Void();
13777 return resultobj;
13778fail:
13779 return NULL;
13780}
13781
13782
13783SWIGINTERN PyObject *_wrap_plwind(PyObject *self, PyObject *args) {
13784 PyObject *resultobj = 0;
13785 PLFLT arg1 ;
13786 PLFLT arg2 ;
13787 PLFLT arg3 ;
13788 PLFLT arg4 ;
13789 double val1 ;
13790 int ecode1 = 0 ;
13791 double val2 ;
13792 int ecode2 = 0 ;
13793 double val3 ;
13794 int ecode3 = 0 ;
13795 double val4 ;
13796 int ecode4 = 0 ;
13797 PyObject *swig_obj[4] ;
13798
13799 if (!SWIG_Python_UnpackTuple(args, "plwind", 4, 4, swig_obj)) SWIG_fail;
13800 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13801 if (!SWIG_IsOK(ecode1)) {
13802 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
13803 }
13804 arg1 = (PLFLT)(val1);
13805 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13806 if (!SWIG_IsOK(ecode2)) {
13807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
13808 }
13809 arg2 = (PLFLT)(val2);
13810 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13811 if (!SWIG_IsOK(ecode3)) {
13812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
13813 }
13814 arg3 = (PLFLT)(val3);
13815 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13816 if (!SWIG_IsOK(ecode4)) {
13817 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
13818 }
13819 arg4 = (PLFLT)(val4);
13820 plwind(arg1,arg2,arg3,arg4);
13821 resultobj = SWIG_Py_Void();
13822 return resultobj;
13823fail:
13824 return NULL;
13825}
13826
13827
13828SWIGINTERN PyObject *_wrap_plxormod(PyObject *self, PyObject *args) {
13829 PyObject *resultobj = 0;
13830 PLBOOL arg1 ;
13831 PLBOOL *arg2 = (PLBOOL *) 0 ;
13832 int val1 ;
13833 int ecode1 = 0 ;
13834 PLBOOL temp2 ;
13835 int res2 = SWIG_TMPOBJ ;
13836 PyObject *swig_obj[1] ;
13837
13838 arg2 = &temp2;
13839 if (!args) SWIG_fail;
13840 swig_obj[0] = args;
13841 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13842 if (!SWIG_IsOK(ecode1)) {
13843 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
13844 }
13845 arg1 = (PLBOOL)(val1);
13846 plxormod(arg1,arg2);
13847 resultobj = SWIG_Py_Void();
13848 if (SWIG_IsTmpObj(res2)) {
13849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
13850 } else {
13851 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13853 }
13854 return resultobj;
13855fail:
13856 return NULL;
13857}
13858
13859
13860SWIGINTERN PyObject *_wrap_plmap(PyObject *self, PyObject *args) {
13861 PyObject *resultobj = 0;
13862 mapform_func arg1 = (mapform_func) 0 ;
13863 char *arg2 = (char *) 0 ;
13864 PLFLT arg3 ;
13865 PLFLT arg4 ;
13866 PLFLT arg5 ;
13867 PLFLT arg6 ;
13868 int res2 ;
13869 char *buf2 = 0 ;
13870 int alloc2 = 0 ;
13871 double val3 ;
13872 int ecode3 = 0 ;
13873 double val4 ;
13874 int ecode4 = 0 ;
13875 double val5 ;
13876 int ecode5 = 0 ;
13877 double val6 ;
13878 int ecode6 = 0 ;
13879 PyObject *swig_obj[6] ;
13880
13881 if (!SWIG_Python_UnpackTuple(args, "plmap", 6, 6, swig_obj)) SWIG_fail;
13882 {
13883 // it must be a callable or none
13884 if ( swig_obj[0] == Py_None )
13885 {
13886 arg1 = NULL;
13887 }
13888 else
13889 {
13890 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13891 {
13892 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13893 return NULL;
13894 }
13895 arg1 = marshal_mapform( swig_obj[0] );
13896 }
13897 }
13898 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13899 if (!SWIG_IsOK(res2)) {
13900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
13901 }
13902 arg2 = (char *)(buf2);
13903 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13904 if (!SWIG_IsOK(ecode3)) {
13905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
13906 }
13907 arg3 = (PLFLT)(val3);
13908 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13909 if (!SWIG_IsOK(ecode4)) {
13910 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
13911 }
13912 arg4 = (PLFLT)(val4);
13913 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13914 if (!SWIG_IsOK(ecode5)) {
13915 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
13916 }
13917 arg5 = (PLFLT)(val5);
13918 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
13919 if (!SWIG_IsOK(ecode6)) {
13920 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
13921 }
13922 arg6 = (PLFLT)(val6);
13923 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
13924 resultobj = SWIG_Py_Void();
13925 {
13927 }
13928 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13929 return resultobj;
13930fail:
13931 {
13933 }
13934 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13935 return NULL;
13936}
13937
13938
13939SWIGINTERN PyObject *_wrap_plmapline(PyObject *self, PyObject *args) {
13940 PyObject *resultobj = 0;
13941 mapform_func arg1 = (mapform_func) 0 ;
13942 char *arg2 = (char *) 0 ;
13943 PLFLT arg3 ;
13944 PLFLT arg4 ;
13945 PLFLT arg5 ;
13946 PLFLT arg6 ;
13947 PLINT *arg7 = (PLINT *) 0 ;
13948 PLINT arg8 ;
13949 int res2 ;
13950 char *buf2 = 0 ;
13951 int alloc2 = 0 ;
13952 double val3 ;
13953 int ecode3 = 0 ;
13954 double val4 ;
13955 int ecode4 = 0 ;
13956 double val5 ;
13957 int ecode5 = 0 ;
13958 double val6 ;
13959 int ecode6 = 0 ;
13960 PyArrayObject *tmp7 = NULL ;
13961 PyObject *swig_obj[7] ;
13962
13963 if (!SWIG_Python_UnpackTuple(args, "plmapline", 7, 7, swig_obj)) SWIG_fail;
13964 {
13965 // it must be a callable or none
13966 if ( swig_obj[0] == Py_None )
13967 {
13968 arg1 = NULL;
13969 }
13970 else
13971 {
13972 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13973 {
13974 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
13975 return NULL;
13976 }
13977 arg1 = marshal_mapform( swig_obj[0] );
13978 }
13979 }
13980 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
13981 if (!SWIG_IsOK(res2)) {
13982 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
13983 }
13984 arg2 = (char *)(buf2);
13985 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13986 if (!SWIG_IsOK(ecode3)) {
13987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
13988 }
13989 arg3 = (PLFLT)(val3);
13990 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13991 if (!SWIG_IsOK(ecode4)) {
13992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
13993 }
13994 arg4 = (PLFLT)(val4);
13995 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13996 if (!SWIG_IsOK(ecode5)) {
13997 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
13998 }
13999 arg5 = (PLFLT)(val5);
14000 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14001 if (!SWIG_IsOK(ecode6)) {
14002 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14003 }
14004 arg6 = (PLFLT)(val6);
14005 {
14006 if ( swig_obj[6] != Py_None )
14007 {
14008 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14009 if ( tmp7 == NULL )
14010 return NULL;
14011 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14012 arg8 = PyArray_DIMS( tmp7 )[0];
14013 }
14014 else
14015 {
14016 arg7 = NULL;
14017 arg8 = 0;
14018 }
14019 }
14020 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14021 resultobj = SWIG_Py_Void();
14022 {
14024 }
14025 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14026 {
14027 Py_CLEAR( tmp7 );
14028 }
14029 return resultobj;
14030fail:
14031 {
14033 }
14034 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14035 {
14036 Py_CLEAR( tmp7 );
14037 }
14038 return NULL;
14039}
14040
14041
14042SWIGINTERN PyObject *_wrap_plmapstring(PyObject *self, PyObject *args) {
14043 PyObject *resultobj = 0;
14044 mapform_func arg1 = (mapform_func) 0 ;
14045 char *arg2 = (char *) 0 ;
14046 char *arg3 = (char *) 0 ;
14047 PLFLT arg4 ;
14048 PLFLT arg5 ;
14049 PLFLT arg6 ;
14050 PLFLT arg7 ;
14051 PLINT *arg8 = (PLINT *) 0 ;
14052 PLINT arg9 ;
14053 int res2 ;
14054 char *buf2 = 0 ;
14055 int alloc2 = 0 ;
14056 int res3 ;
14057 char *buf3 = 0 ;
14058 int alloc3 = 0 ;
14059 double val4 ;
14060 int ecode4 = 0 ;
14061 double val5 ;
14062 int ecode5 = 0 ;
14063 double val6 ;
14064 int ecode6 = 0 ;
14065 double val7 ;
14066 int ecode7 = 0 ;
14067 PyArrayObject *tmp8 = NULL ;
14068 PyObject *swig_obj[8] ;
14069
14070 if (!SWIG_Python_UnpackTuple(args, "plmapstring", 8, 8, swig_obj)) SWIG_fail;
14071 {
14072 // it must be a callable or none
14073 if ( swig_obj[0] == Py_None )
14074 {
14075 arg1 = NULL;
14076 }
14077 else
14078 {
14079 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14080 {
14081 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14082 return NULL;
14083 }
14084 arg1 = marshal_mapform( swig_obj[0] );
14085 }
14086 }
14087 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14088 if (!SWIG_IsOK(res2)) {
14089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14090 }
14091 arg2 = (char *)(buf2);
14092 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
14093 if (!SWIG_IsOK(res3)) {
14094 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14095 }
14096 arg3 = (char *)(buf3);
14097 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14098 if (!SWIG_IsOK(ecode4)) {
14099 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14100 }
14101 arg4 = (PLFLT)(val4);
14102 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14103 if (!SWIG_IsOK(ecode5)) {
14104 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14105 }
14106 arg5 = (PLFLT)(val5);
14107 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14108 if (!SWIG_IsOK(ecode6)) {
14109 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14110 }
14111 arg6 = (PLFLT)(val6);
14112 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14113 if (!SWIG_IsOK(ecode7)) {
14114 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14115 }
14116 arg7 = (PLFLT)(val7);
14117 {
14118 if ( swig_obj[7] != Py_None )
14119 {
14120 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
14121 if ( tmp8 == NULL )
14122 return NULL;
14123 arg8 = (PLINT *) PyArray_DATA( tmp8 );
14124 arg9 = PyArray_DIMS( tmp8 )[0];
14125 }
14126 else
14127 {
14128 arg8 = NULL;
14129 arg9 = 0;
14130 }
14131 }
14132 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14133 resultobj = SWIG_Py_Void();
14134 {
14136 }
14137 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14138 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14139 {
14140 Py_CLEAR( tmp8 );
14141 }
14142 return resultobj;
14143fail:
14144 {
14146 }
14147 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14148 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14149 {
14150 Py_CLEAR( tmp8 );
14151 }
14152 return NULL;
14153}
14154
14155
14156SWIGINTERN PyObject *_wrap_plmaptex(PyObject *self, PyObject *args) {
14157 PyObject *resultobj = 0;
14158 mapform_func arg1 = (mapform_func) 0 ;
14159 char *arg2 = (char *) 0 ;
14160 PLFLT arg3 ;
14161 PLFLT arg4 ;
14162 PLFLT arg5 ;
14163 char *arg6 = (char *) 0 ;
14164 PLFLT arg7 ;
14165 PLFLT arg8 ;
14166 PLFLT arg9 ;
14167 PLFLT arg10 ;
14168 PLINT arg11 ;
14169 int res2 ;
14170 char *buf2 = 0 ;
14171 int alloc2 = 0 ;
14172 double val3 ;
14173 int ecode3 = 0 ;
14174 double val4 ;
14175 int ecode4 = 0 ;
14176 double val5 ;
14177 int ecode5 = 0 ;
14178 int res6 ;
14179 char *buf6 = 0 ;
14180 int alloc6 = 0 ;
14181 double val7 ;
14182 int ecode7 = 0 ;
14183 double val8 ;
14184 int ecode8 = 0 ;
14185 double val9 ;
14186 int ecode9 = 0 ;
14187 double val10 ;
14188 int ecode10 = 0 ;
14189 int val11 ;
14190 int ecode11 = 0 ;
14191 PyObject *swig_obj[11] ;
14192
14193 if (!SWIG_Python_UnpackTuple(args, "plmaptex", 11, 11, swig_obj)) SWIG_fail;
14194 {
14195 // it must be a callable or none
14196 if ( swig_obj[0] == Py_None )
14197 {
14198 arg1 = NULL;
14199 }
14200 else
14201 {
14202 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14203 {
14204 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14205 return NULL;
14206 }
14207 arg1 = marshal_mapform( swig_obj[0] );
14208 }
14209 }
14210 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14211 if (!SWIG_IsOK(res2)) {
14212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14213 }
14214 arg2 = (char *)(buf2);
14215 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14216 if (!SWIG_IsOK(ecode3)) {
14217 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14218 }
14219 arg3 = (PLFLT)(val3);
14220 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14221 if (!SWIG_IsOK(ecode4)) {
14222 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14223 }
14224 arg4 = (PLFLT)(val4);
14225 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14226 if (!SWIG_IsOK(ecode5)) {
14227 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14228 }
14229 arg5 = (PLFLT)(val5);
14230 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
14231 if (!SWIG_IsOK(res6)) {
14232 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14233 }
14234 arg6 = (char *)(buf6);
14235 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14236 if (!SWIG_IsOK(ecode7)) {
14237 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14238 }
14239 arg7 = (PLFLT)(val7);
14240 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14241 if (!SWIG_IsOK(ecode8)) {
14242 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14243 }
14244 arg8 = (PLFLT)(val8);
14245 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14246 if (!SWIG_IsOK(ecode9)) {
14247 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14248 }
14249 arg9 = (PLFLT)(val9);
14250 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14251 if (!SWIG_IsOK(ecode10)) {
14252 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14253 }
14254 arg10 = (PLFLT)(val10);
14255 ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
14256 if (!SWIG_IsOK(ecode11)) {
14257 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14258 }
14259 arg11 = (PLINT)(val11);
14260 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14261 resultobj = SWIG_Py_Void();
14262 {
14264 }
14265 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14266 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14267 return resultobj;
14268fail:
14269 {
14271 }
14272 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14273 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14274 return NULL;
14275}
14276
14277
14278SWIGINTERN PyObject *_wrap_plmapfill(PyObject *self, PyObject *args) {
14279 PyObject *resultobj = 0;
14280 mapform_func arg1 = (mapform_func) 0 ;
14281 char *arg2 = (char *) 0 ;
14282 PLFLT arg3 ;
14283 PLFLT arg4 ;
14284 PLFLT arg5 ;
14285 PLFLT arg6 ;
14286 PLINT *arg7 = (PLINT *) 0 ;
14287 PLINT arg8 ;
14288 int res2 ;
14289 char *buf2 = 0 ;
14290 int alloc2 = 0 ;
14291 double val3 ;
14292 int ecode3 = 0 ;
14293 double val4 ;
14294 int ecode4 = 0 ;
14295 double val5 ;
14296 int ecode5 = 0 ;
14297 double val6 ;
14298 int ecode6 = 0 ;
14299 PyArrayObject *tmp7 = NULL ;
14300 PyObject *swig_obj[7] ;
14301
14302 if (!SWIG_Python_UnpackTuple(args, "plmapfill", 7, 7, swig_obj)) SWIG_fail;
14303 {
14304 // it must be a callable or none
14305 if ( swig_obj[0] == Py_None )
14306 {
14307 arg1 = NULL;
14308 }
14309 else
14310 {
14311 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14312 {
14313 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14314 return NULL;
14315 }
14316 arg1 = marshal_mapform( swig_obj[0] );
14317 }
14318 }
14319 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14320 if (!SWIG_IsOK(res2)) {
14321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14322 }
14323 arg2 = (char *)(buf2);
14324 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14325 if (!SWIG_IsOK(ecode3)) {
14326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14327 }
14328 arg3 = (PLFLT)(val3);
14329 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14330 if (!SWIG_IsOK(ecode4)) {
14331 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14332 }
14333 arg4 = (PLFLT)(val4);
14334 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14335 if (!SWIG_IsOK(ecode5)) {
14336 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14337 }
14338 arg5 = (PLFLT)(val5);
14339 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14340 if (!SWIG_IsOK(ecode6)) {
14341 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14342 }
14343 arg6 = (PLFLT)(val6);
14344 {
14345 if ( swig_obj[6] != Py_None )
14346 {
14347 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14348 if ( tmp7 == NULL )
14349 return NULL;
14350 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14351 arg8 = PyArray_DIMS( tmp7 )[0];
14352 }
14353 else
14354 {
14355 arg7 = NULL;
14356 arg8 = 0;
14357 }
14358 }
14359 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14360 resultobj = SWIG_Py_Void();
14361 {
14363 }
14364 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14365 {
14366 Py_CLEAR( tmp7 );
14367 }
14368 return resultobj;
14369fail:
14370 {
14372 }
14373 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14374 {
14375 Py_CLEAR( tmp7 );
14376 }
14377 return NULL;
14378}
14379
14380
14381SWIGINTERN PyObject *_wrap_plmeridians(PyObject *self, PyObject *args) {
14382 PyObject *resultobj = 0;
14383 mapform_func arg1 = (mapform_func) 0 ;
14384 PLFLT arg2 ;
14385 PLFLT arg3 ;
14386 PLFLT arg4 ;
14387 PLFLT arg5 ;
14388 PLFLT arg6 ;
14389 PLFLT arg7 ;
14390 double val2 ;
14391 int ecode2 = 0 ;
14392 double val3 ;
14393 int ecode3 = 0 ;
14394 double val4 ;
14395 int ecode4 = 0 ;
14396 double val5 ;
14397 int ecode5 = 0 ;
14398 double val6 ;
14399 int ecode6 = 0 ;
14400 double val7 ;
14401 int ecode7 = 0 ;
14402 PyObject *swig_obj[7] ;
14403
14404 if (!SWIG_Python_UnpackTuple(args, "plmeridians", 7, 7, swig_obj)) SWIG_fail;
14405 {
14406 // it must be a callable or none
14407 if ( swig_obj[0] == Py_None )
14408 {
14409 arg1 = NULL;
14410 }
14411 else
14412 {
14413 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14414 {
14415 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14416 return NULL;
14417 }
14418 arg1 = marshal_mapform( swig_obj[0] );
14419 }
14420 }
14421 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14422 if (!SWIG_IsOK(ecode2)) {
14423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14424 }
14425 arg2 = (PLFLT)(val2);
14426 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14427 if (!SWIG_IsOK(ecode3)) {
14428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14429 }
14430 arg3 = (PLFLT)(val3);
14431 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14432 if (!SWIG_IsOK(ecode4)) {
14433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14434 }
14435 arg4 = (PLFLT)(val4);
14436 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14437 if (!SWIG_IsOK(ecode5)) {
14438 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14439 }
14440 arg5 = (PLFLT)(val5);
14441 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14442 if (!SWIG_IsOK(ecode6)) {
14443 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14444 }
14445 arg6 = (PLFLT)(val6);
14446 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14447 if (!SWIG_IsOK(ecode7)) {
14448 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14449 }
14450 arg7 = (PLFLT)(val7);
14451 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14452 resultobj = SWIG_Py_Void();
14453 {
14455 }
14456 return resultobj;
14457fail:
14458 {
14460 }
14461 return NULL;
14462}
14463
14464
14465SWIGINTERN PyObject *_wrap_plimage(PyObject *self, PyObject *args) {
14466 PyObject *resultobj = 0;
14467 PLFLT **arg1 = (PLFLT **) 0 ;
14468 PLINT arg2 ;
14469 PLINT arg3 ;
14470 PLFLT arg4 ;
14471 PLFLT arg5 ;
14472 PLFLT arg6 ;
14473 PLFLT arg7 ;
14474 PLFLT arg8 ;
14475 PLFLT arg9 ;
14476 PLFLT arg10 ;
14477 PLFLT arg11 ;
14478 PLFLT arg12 ;
14479 PLFLT arg13 ;
14480 PyArrayObject *tmp1 = NULL ;
14481 double val4 ;
14482 int ecode4 = 0 ;
14483 double val5 ;
14484 int ecode5 = 0 ;
14485 double val6 ;
14486 int ecode6 = 0 ;
14487 double val7 ;
14488 int ecode7 = 0 ;
14489 double val8 ;
14490 int ecode8 = 0 ;
14491 double val9 ;
14492 int ecode9 = 0 ;
14493 double val10 ;
14494 int ecode10 = 0 ;
14495 double val11 ;
14496 int ecode11 = 0 ;
14497 double val12 ;
14498 int ecode12 = 0 ;
14499 double val13 ;
14500 int ecode13 = 0 ;
14501 PyObject *swig_obj[11] ;
14502
14503 if (!SWIG_Python_UnpackTuple(args, "plimage", 11, 11, swig_obj)) SWIG_fail;
14504 {
14505 int i, size;
14506 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14507 if ( tmp1 == NULL )
14508 return NULL;
14509 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14510 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14511 size = arg3;
14512 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14513 for ( i = 0; i < arg2; i++ )
14514 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14515 }
14516 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14517 if (!SWIG_IsOK(ecode4)) {
14518 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14519 }
14520 arg4 = (PLFLT)(val4);
14521 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14522 if (!SWIG_IsOK(ecode5)) {
14523 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14524 }
14525 arg5 = (PLFLT)(val5);
14526 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14527 if (!SWIG_IsOK(ecode6)) {
14528 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14529 }
14530 arg6 = (PLFLT)(val6);
14531 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14532 if (!SWIG_IsOK(ecode7)) {
14533 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14534 }
14535 arg7 = (PLFLT)(val7);
14536 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14537 if (!SWIG_IsOK(ecode8)) {
14538 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14539 }
14540 arg8 = (PLFLT)(val8);
14541 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14542 if (!SWIG_IsOK(ecode9)) {
14543 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14544 }
14545 arg9 = (PLFLT)(val9);
14546 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14547 if (!SWIG_IsOK(ecode10)) {
14548 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14549 }
14550 arg10 = (PLFLT)(val10);
14551 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14552 if (!SWIG_IsOK(ecode11)) {
14553 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14554 }
14555 arg11 = (PLFLT)(val11);
14556 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
14557 if (!SWIG_IsOK(ecode12)) {
14558 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14559 }
14560 arg12 = (PLFLT)(val12);
14561 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
14562 if (!SWIG_IsOK(ecode13)) {
14563 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14564 }
14565 arg13 = (PLFLT)(val13);
14566 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14567 resultobj = SWIG_Py_Void();
14568 {
14569 Py_CLEAR( tmp1 );
14570 free( arg1 );
14571 }
14572 return resultobj;
14573fail:
14574 {
14575 Py_CLEAR( tmp1 );
14576 free( arg1 );
14577 }
14578 return NULL;
14579}
14580
14581
14582SWIGINTERN PyObject *_wrap_plimagefr(PyObject *self, PyObject *args) {
14583 PyObject *resultobj = 0;
14584 PLFLT **arg1 = (PLFLT **) 0 ;
14585 PLINT arg2 ;
14586 PLINT arg3 ;
14587 PLFLT arg4 ;
14588 PLFLT arg5 ;
14589 PLFLT arg6 ;
14590 PLFLT arg7 ;
14591 PLFLT arg8 ;
14592 PLFLT arg9 ;
14593 PLFLT arg10 ;
14594 PLFLT arg11 ;
14595 pltr_func arg12 = (pltr_func) 0 ;
14596 PLPointer arg13 = (PLPointer) 0 ;
14597 PyArrayObject *tmp1 = NULL ;
14598 double val4 ;
14599 int ecode4 = 0 ;
14600 double val5 ;
14601 int ecode5 = 0 ;
14602 double val6 ;
14603 int ecode6 = 0 ;
14604 double val7 ;
14605 int ecode7 = 0 ;
14606 double val8 ;
14607 int ecode8 = 0 ;
14608 double val9 ;
14609 int ecode9 = 0 ;
14610 double val10 ;
14611 int ecode10 = 0 ;
14612 double val11 ;
14613 int ecode11 = 0 ;
14614 PyObject *swig_obj[11] ;
14615
14616 {
14617 python_pltr = 0;
14618 arg12 = NULL;
14619 }
14620 {
14621 arg13 = NULL;
14622 }
14623 if (!SWIG_Python_UnpackTuple(args, "plimagefr", 9, 11, swig_obj)) SWIG_fail;
14624 {
14625 int i, size;
14626 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14627 if ( tmp1 == NULL )
14628 return NULL;
14629 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14630 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14631 size = arg3;
14632 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14633 for ( i = 0; i < arg2; i++ )
14634 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14635 }
14636 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14637 if (!SWIG_IsOK(ecode4)) {
14638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14639 }
14640 arg4 = (PLFLT)(val4);
14641 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14642 if (!SWIG_IsOK(ecode5)) {
14643 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14644 }
14645 arg5 = (PLFLT)(val5);
14646 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14647 if (!SWIG_IsOK(ecode6)) {
14648 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14649 }
14650 arg6 = (PLFLT)(val6);
14651 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14652 if (!SWIG_IsOK(ecode7)) {
14653 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14654 }
14655 arg7 = (PLFLT)(val7);
14656 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14657 if (!SWIG_IsOK(ecode8)) {
14658 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14659 }
14660 arg8 = (PLFLT)(val8);
14661 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14662 if (!SWIG_IsOK(ecode9)) {
14663 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14664 }
14665 arg9 = (PLFLT)(val9);
14666 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14667 if (!SWIG_IsOK(ecode10)) {
14668 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14669 }
14670 arg10 = (PLFLT)(val10);
14671 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14672 if (!SWIG_IsOK(ecode11)) {
14673 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14674 }
14675 arg11 = (PLFLT)(val11);
14676 if (swig_obj[9]) {
14677 {
14678 // it must be a callable or None
14679 if ( swig_obj[9] == Py_None )
14680 {
14681 arg12 = NULL;
14682 }
14683 else
14684 {
14685 if ( !PyCallable_Check( (PyObject *) swig_obj[9] ) )
14686 {
14687 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
14688 return NULL;
14689 }
14690 arg12 = marshal_pltr( swig_obj[9] );
14691 }
14692 }
14693 }
14694 if (swig_obj[10]) {
14695 {
14696 if ( swig_obj[10] == Py_None )
14697 arg13 = NULL;
14698 else
14699 {
14700 arg13 = marshal_PLPointer( swig_obj[10], 1 );
14701 }
14702 }
14703 }
14704 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14705 resultobj = SWIG_Py_Void();
14706 {
14707 Py_CLEAR( tmp1 );
14708 free( arg1 );
14709 }
14710 {
14711 cleanup_pltr();
14712 }
14713 {
14715 }
14716 return resultobj;
14717fail:
14718 {
14719 Py_CLEAR( tmp1 );
14720 free( arg1 );
14721 }
14722 {
14723 cleanup_pltr();
14724 }
14725 {
14727 }
14728 return NULL;
14729}
14730
14731
14732SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *self, PyObject *args) {
14733 PyObject *resultobj = 0;
14734
14735 if (!SWIG_Python_UnpackTuple(args, "plClearOpts", 0, 0, 0)) SWIG_fail;
14736 plClearOpts();
14737 resultobj = SWIG_Py_Void();
14738 return resultobj;
14739fail:
14740 return NULL;
14741}
14742
14743
14744SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *self, PyObject *args) {
14745 PyObject *resultobj = 0;
14746
14747 if (!SWIG_Python_UnpackTuple(args, "plResetOpts", 0, 0, 0)) SWIG_fail;
14748 plResetOpts();
14749 resultobj = SWIG_Py_Void();
14750 return resultobj;
14751fail:
14752 return NULL;
14753}
14754
14755
14756SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *self, PyObject *args) {
14757 PyObject *resultobj = 0;
14758 char *arg1 = (char *) 0 ;
14759 char *arg2 = (char *) 0 ;
14760 int res1 ;
14761 char *buf1 = 0 ;
14762 int alloc1 = 0 ;
14763 int res2 ;
14764 char *buf2 = 0 ;
14765 int alloc2 = 0 ;
14766 PyObject *swig_obj[2] ;
14767
14768 if (!SWIG_Python_UnpackTuple(args, "plSetUsage", 2, 2, swig_obj)) SWIG_fail;
14769 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
14770 if (!SWIG_IsOK(res1)) {
14771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
14772 }
14773 arg1 = (char *)(buf1);
14774 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14775 if (!SWIG_IsOK(res2)) {
14776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
14777 }
14778 arg2 = (char *)(buf2);
14779 plSetUsage((char const *)arg1,(char const *)arg2);
14780 resultobj = SWIG_Py_Void();
14781 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14782 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14783 return resultobj;
14784fail:
14785 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
14786 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14787 return NULL;
14788}
14789
14790
14791SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *self, PyObject *args) {
14792 PyObject *resultobj = 0;
14793
14794 if (!SWIG_Python_UnpackTuple(args, "plOptUsage", 0, 0, 0)) SWIG_fail;
14795 plOptUsage();
14796 resultobj = SWIG_Py_Void();
14797 return resultobj;
14798fail:
14799 return NULL;
14800}
14801
14802
14803SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *self, PyObject *args) {
14804 PyObject *resultobj = 0;
14805 PLFLT **arg1 = (PLFLT **) 0 ;
14806 PLINT arg2 ;
14807 PLINT arg3 ;
14808 PLFLT *arg4 = (PLFLT *) 0 ;
14809 PLFLT *arg5 = (PLFLT *) 0 ;
14810 PyArrayObject *tmp1 = NULL ;
14811 PLFLT temp4 ;
14812 int res4 = SWIG_TMPOBJ ;
14813 PLFLT temp5 ;
14814 int res5 = SWIG_TMPOBJ ;
14815 PyObject *swig_obj[1] ;
14816
14817 arg4 = &temp4;
14818 arg5 = &temp5;
14819 if (!args) SWIG_fail;
14820 swig_obj[0] = args;
14821 {
14822 int i, size;
14823 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14824 if ( tmp1 == NULL )
14825 return NULL;
14826 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14827 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14828 size = arg3;
14829 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14830 for ( i = 0; i < arg2; i++ )
14831 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14832 }
14833 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
14834 resultobj = SWIG_Py_Void();
14835 if (SWIG_IsTmpObj(res4)) {
14836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
14837 } else {
14838 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14840 }
14841 if (SWIG_IsTmpObj(res5)) {
14842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
14843 } else {
14844 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
14846 }
14847 {
14848 Py_CLEAR( tmp1 );
14849 free( arg1 );
14850 }
14851 return resultobj;
14852fail:
14853 {
14854 Py_CLEAR( tmp1 );
14855 free( arg1 );
14856 }
14857 return NULL;
14858}
14859
14860
14861SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *self, PyObject *args) {
14862 PyObject *resultobj = 0;
14863 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
14864 void *argp1 = 0 ;
14865 int res1 = 0 ;
14866 PyObject *swig_obj[1] ;
14867 PLINT result;
14868
14869 if (!args) SWIG_fail;
14870 swig_obj[0] = args;
14871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
14872 if (!SWIG_IsOK(res1)) {
14873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
14874 }
14875 arg1 = (PLGraphicsIn *)(argp1);
14876 result = (PLINT)plGetCursor(arg1);
14877 resultobj = SWIG_From_int((int)(result));
14878 return resultobj;
14879fail:
14880 return NULL;
14881}
14882
14883
14884static PyMethodDef SwigMethods[] = {
14885 { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
14886 { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
14887 { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
14888 { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
14889 { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_O, NULL},
14890 { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
14891 { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_O, NULL},
14892 { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
14893 { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_O, NULL},
14894 { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
14895 { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_O, NULL},
14896 { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
14897 { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_O, NULL},
14898 { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
14899 { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_O, NULL},
14900 { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
14901 { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_O, NULL},
14902 { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
14903 { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_O, NULL},
14904 { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
14905 { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_O, NULL},
14906 { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
14907 { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_O, NULL},
14908 { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
14909 { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_O, NULL},
14910 { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
14911 { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_O, NULL},
14912 { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_NOARGS, NULL},
14913 { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_O, NULL},
14914 { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_O, NULL},
14915 { "PLGraphicsIn_swiginit", PLGraphicsIn_swiginit, METH_VARARGS, NULL},
14916 { "plsxwin", _wrap_plsxwin, METH_O, NULL},
14917 { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, "\n"
14918 "Set format of numerical label for contours\n"
14919 "\n"
14920 "DESCRIPTION:\n"
14921 "\n"
14922 " Set format of numerical label for contours.\n"
14923 "\n"
14924 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
14925 "\n"
14926 " This function is used example 9.\n"
14927 "\n"
14928 "\n"
14929 "\n"
14930 "SYNOPSIS:\n"
14931 "\n"
14932 "pl_setcontlabelformat(lexp, sigdig)\n"
14933 "\n"
14934 "ARGUMENTS:\n"
14935 "\n"
14936 " lexp (PLINT, input) : If the contour numerical label is greater\n"
14937 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
14938 " format is used. Default value of lexp is 4.\n"
14939 "\n"
14940 " sigdig (PLINT, input) : Number of significant digits. Default\n"
14941 " value is 2.\n"
14942 "\n"
14943 ""},
14944 { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, "\n"
14945 "Set parameters of contour labelling other than format of numerical label\n"
14946 "\n"
14947 "DESCRIPTION:\n"
14948 "\n"
14949 " Set parameters of contour labelling other than those handled by\n"
14950 " pl_setcontlabelformat.\n"
14951 "\n"
14952 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
14953 "\n"
14954 " This function is used in example 9.\n"
14955 "\n"
14956 "\n"
14957 "\n"
14958 "SYNOPSIS:\n"
14959 "\n"
14960 "pl_setcontlabelparam(offset, size, spacing, active)\n"
14961 "\n"
14962 "ARGUMENTS:\n"
14963 "\n"
14964 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
14965 " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
14966 "\n"
14967 " size (PLFLT, input) : Font height for contour labels (normalized).\n"
14968 " Default value is 0.3.\n"
14969 "\n"
14970 " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
14971 " Default value is 0.1.\n"
14972 "\n"
14973 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
14974 " contour labels on. Default is off (0).\n"
14975 "\n"
14976 ""},
14977 { "pladv", _wrap_pladv, METH_O, "\n"
14978 "Advance the (sub-)page\n"
14979 "\n"
14980 "DESCRIPTION:\n"
14981 "\n"
14982 " Advances to the next subpage if sub=0, performing a page advance if\n"
14983 " there are no remaining subpages on the current page. If subpages\n"
14984 " aren't being used, pladv(0) will always advance the page. If page>0,\n"
14985 " PLplot switches to the specified subpage. Note that this allows you\n"
14986 " to overwrite a plot on the specified subpage; if this is not what you\n"
14987 " intended, use pleop followed by plbop to first advance the page. This\n"
14988 " routine is called automatically (with page=0) by plenv, but if plenv\n"
14989 " is not used, pladv must be called after initializing PLplot but before\n"
14990 " defining the viewport.\n"
14991 "\n"
14992 " Redacted form: pladv(page)\n"
14993 "\n"
14994 " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
14995 " 29, and 31.\n"
14996 "\n"
14997 "\n"
14998 "\n"
14999 "SYNOPSIS:\n"
15000 "\n"
15001 "pladv(page)\n"
15002 "\n"
15003 "ARGUMENTS:\n"
15004 "\n"
15005 " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15006 " in the top left corner and increasing along the rows) to which to\n"
15007 " advance. Set to zero to advance to the next subpage (or to the\n"
15008 " next page if subpages are not being used).\n"
15009 "\n"
15010 ""},
15011 { "plarc", _wrap_plarc, METH_VARARGS, "\n"
15012 "Draw a circular or elliptical arc\n"
15013 "\n"
15014 "DESCRIPTION:\n"
15015 "\n"
15016 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15017 " semiminor axis b, starting at angle1 and ending at angle2.\n"
15018 "\n"
15019 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15020 " fill)\n"
15021 "\n"
15022 "\n"
15023 " This function is used in examples 3 and 27.\n"
15024 "\n"
15025 "\n"
15026 "\n"
15027 "SYNOPSIS:\n"
15028 "\n"
15029 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15030 "\n"
15031 "ARGUMENTS:\n"
15032 "\n"
15033 " x (PLFLT, input) : X coordinate of arc center.\n"
15034 "\n"
15035 " y (PLFLT, input) : Y coordinate of arc center.\n"
15036 "\n"
15037 " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15038 "\n"
15039 " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15040 "\n"
15041 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15042 " semimajor axis.\n"
15043 "\n"
15044 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15045 " semimajor axis.\n"
15046 "\n"
15047 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15048 " X-axis.\n"
15049 "\n"
15050 " fill (PLBOOL, input) : Draw a filled arc.\n"
15051 "\n"
15052 ""},
15053 { "plaxes", _wrap_plaxes, METH_VARARGS, "\n"
15054 "Draw a box with axes, etc. with arbitrary origin\n"
15055 "\n"
15056 "DESCRIPTION:\n"
15057 "\n"
15058 " Draws a box around the currently defined viewport with arbitrary\n"
15059 " world-coordinate origin specified by x0 and y0 and labels it with\n"
15060 " world coordinate values appropriate to the window. Thus plaxes should\n"
15061 " only be called after defining both viewport and window. The ascii\n"
15062 " character strings xopt and yopt specify how the box should be drawn as\n"
15063 " described below. If ticks and/or subticks are to be drawn for a\n"
15064 " particular axis, the tick intervals and number of subintervals may be\n"
15065 " specified explicitly, or they may be defaulted by setting the\n"
15066 " appropriate arguments to zero.\n"
15067 "\n"
15068 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15069 " ytick, nysub)\n"
15070 "\n"
15071 "\n"
15072 " This function is not used in any examples.\n"
15073 "\n"
15074 "\n"
15075 "\n"
15076 "SYNOPSIS:\n"
15077 "\n"
15078 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15079 "\n"
15080 "ARGUMENTS:\n"
15081 "\n"
15082 " x0 (PLFLT, input) : World X coordinate of origin.\n"
15083 "\n"
15084 " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15085 "\n"
15086 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15087 " options for the x axis. The string can include any combination of\n"
15088 " the following letters (upper or lower case) in any order: a: Draws\n"
15089 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15090 " (x=0).\n"
15091 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15092 " c: Draws top (X) or right (Y) edge of frame.\n"
15093 " d: Plot labels as date / time. Values are assumed to be\n"
15094 " seconds since the epoch (as used by gmtime).\n"
15095 " f: Always use fixed point numeric labels.\n"
15096 " g: Draws a grid at the major tick interval.\n"
15097 " h: Draws a grid at the minor tick interval.\n"
15098 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15099 " inwards.\n"
15100 " l: Labels axis logarithmically. This only affects the labels,\n"
15101 " not the data, and so it is necessary to compute the logarithms\n"
15102 " of data points before passing them to any of the drawing\n"
15103 " routines.\n"
15104 " m: Writes numeric labels at major tick intervals in the\n"
15105 " unconventional location (above box for X, right of box for Y).\n"
15106 " n: Writes numeric labels at major tick intervals in the\n"
15107 " conventional location (below box for X, left of box for Y).\n"
15108 " o: Use custom labelling function to generate axis label text.\n"
15109 " The custom labelling function can be defined with the\n"
15110 " plslabelfunc command.\n"
15111 " s: Enables subticks between major ticks, only valid if t is\n"
15112 " also specified.\n"
15113 " t: Draws major ticks.\n"
15114 " u: Exactly like \"b\" except don't draw edge line.\n"
15115 " w: Exactly like \"c\" except don't draw edge line.\n"
15116 " x: Exactly like \"t\" (including the side effect of the\n"
15117 " numerical labels for the major ticks) except exclude drawing\n"
15118 " the major and minor tick marks.\n"
15119 "\n"
15120 "\n"
15121 " xtick (PLFLT, input) : World coordinate interval between major\n"
15122 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15123 " generates a suitable tick interval.\n"
15124 "\n"
15125 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15126 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15127 " generates a suitable minor tick interval.\n"
15128 "\n"
15129 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15130 " options for the y axis. The string can include any combination of\n"
15131 " the letters defined above for xopt, and in addition may contain:\n"
15132 " v: Write numeric labels for the y axis parallel to the base of the\n"
15133 " graph, rather than parallel to the axis.\n"
15134 "\n"
15135 "\n"
15136 " ytick (PLFLT, input) : World coordinate interval between major\n"
15137 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15138 " generates a suitable tick interval.\n"
15139 "\n"
15140 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15141 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15142 " generates a suitable minor tick interval.\n"
15143 "\n"
15144 ""},
15145 { "plbin", _wrap_plbin, METH_VARARGS, "\n"
15146 "Plot a histogram from binned data\n"
15147 "\n"
15148 "DESCRIPTION:\n"
15149 "\n"
15150 " Plots a histogram consisting of nbin bins. The value associated with\n"
15151 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15152 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15153 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15154 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15155 " placed midway between the values in the x vector. Also see plhist for\n"
15156 " drawing histograms from unbinned data.\n"
15157 "\n"
15158 " Redacted form: General: plbin(x, y, opt)\n"
15159 " Python: plbin(nbin, x, y, opt)\n"
15160 "\n"
15161 "\n"
15162 " This function is not used in any examples.\n"
15163 "\n"
15164 "\n"
15165 "\n"
15166 "SYNOPSIS:\n"
15167 "\n"
15168 "plbin(nbin, x, y, opt)\n"
15169 "\n"
15170 "ARGUMENTS:\n"
15171 "\n"
15172 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15173 " and y vectors.)\n"
15174 "\n"
15175 " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15176 " with bins. These must form a strictly increasing sequence.\n"
15177 "\n"
15178 " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15179 " proportional to the number of points in each bin. This is a PLFLT\n"
15180 " (instead of PLINT) vector so as to allow histograms of\n"
15181 " probabilities, etc.\n"
15182 "\n"
15183 " opt (PLINT, input) : Is a combination of several flags:\n"
15184 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15185 " outer bins are expanded to fill up the entire x-axis and bins of\n"
15186 " zero height are simply drawn.\n"
15187 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15188 " between the x values. If the values in x are equally spaced,\n"
15189 " the values are the center values of the bins.\n"
15190 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15191 " size as the ones inside.\n"
15192 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15193 " (there is a gap for such bins).\n"
15194 "\n"
15195 ""},
15196 { "plbtime", _wrap_plbtime, METH_O, "\n"
15197 "Calculate broken-down time from continuous time for the current stream\n"
15198 "\n"
15199 "DESCRIPTION:\n"
15200 "\n"
15201 " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15202 " continuous time, ctime for the current stream. This function is the\n"
15203 " inverse of plctime.\n"
15204 "\n"
15205 " The PLplot definition of broken-down time is a calendar time that\n"
15206 " completely ignores all time zone offsets, i.e., it is the user's\n"
15207 " responsibility to apply those offsets (if so desired) before using the\n"
15208 " PLplot time API. By default broken-down time is defined using the\n"
15209 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15210 " continuous time is defined as the number of seconds since the Unix\n"
15211 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15212 " broken-down and continuous time are possible, see plconfigtime.\n"
15213 "\n"
15214 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15215 " ctime)\n"
15216 "\n"
15217 "\n"
15218 " This function is used in example 29.\n"
15219 "\n"
15220 "\n"
15221 "\n"
15222 "SYNOPSIS:\n"
15223 "\n"
15224 "plbtime(year, month, day, hour, min, sec, ctime)\n"
15225 "\n"
15226 "ARGUMENTS:\n"
15227 "\n"
15228 " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15229 " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15230 " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15231 " BCE, etc.)\n"
15232 "\n"
15233 " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15234 " the year in the range from 0 (January) to 11 (December).\n"
15235 "\n"
15236 " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15237 " month in the range from 1 to 31.\n"
15238 "\n"
15239 " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15240 " day in the range from 0 to 23.\n"
15241 "\n"
15242 " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15243 " hour in the range from 0 to 59\n"
15244 "\n"
15245 " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15246 " minute in range from 0. to 60.\n"
15247 "\n"
15248 " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
15249 " time is calculated.\n"
15250 "\n"
15251 ""},
15252 { "plbop", _wrap_plbop, METH_NOARGS, "\n"
15253 "Begin a new page\n"
15254 "\n"
15255 "DESCRIPTION:\n"
15256 "\n"
15257 " Begins a new page. For a file driver, the output file is opened if\n"
15258 " necessary. Advancing the page via pleop and plbop is useful when a\n"
15259 " page break is desired at a particular point when plotting to subpages.\n"
15260 " Another use for pleop and plbop is when plotting pages to different\n"
15261 " files, since you can manually set the file name by calling plsfnam\n"
15262 " after the call to pleop. (In fact some drivers may only support a\n"
15263 " single page per file, making this a necessity.) One way to handle\n"
15264 " this case automatically is to page advance via pladv, but enable\n"
15265 " familying (see plsfam) with a small limit on the file size so that a\n"
15266 " new family member file will be created on each page break.\n"
15267 "\n"
15268 " Redacted form: plbop()\n"
15269 "\n"
15270 " This function is used in examples 2 and 20.\n"
15271 "\n"
15272 "\n"
15273 "\n"
15274 "SYNOPSIS:\n"
15275 "\n"
15276 "plbop()\n"
15277 "\n"
15278 ""},
15279 { "plbox", _wrap_plbox, METH_VARARGS, "\n"
15280 "Draw a box with axes, etc\n"
15281 "\n"
15282 "DESCRIPTION:\n"
15283 "\n"
15284 " Draws a box around the currently defined viewport, and labels it with\n"
15285 " world coordinate values appropriate to the window. Thus plbox should\n"
15286 " only be called after defining both viewport and window. The ascii\n"
15287 " character strings xopt and yopt specify how the box should be drawn as\n"
15288 " described below. If ticks and/or subticks are to be drawn for a\n"
15289 " particular axis, the tick intervals and number of subintervals may be\n"
15290 " specified explicitly, or they may be defaulted by setting the\n"
15291 " appropriate arguments to zero.\n"
15292 "\n"
15293 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15294 "\n"
15295 "\n"
15296 " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15297 " and 29.\n"
15298 "\n"
15299 "\n"
15300 "\n"
15301 "SYNOPSIS:\n"
15302 "\n"
15303 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15304 "\n"
15305 "ARGUMENTS:\n"
15306 "\n"
15307 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15308 " options for the x axis. The string can include any combination of\n"
15309 " the following letters (upper or lower case) in any order: a: Draws\n"
15310 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15311 " (x=0).\n"
15312 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15313 " c: Draws top (X) or right (Y) edge of frame.\n"
15314 " d: Plot labels as date / time. Values are assumed to be\n"
15315 " seconds since the epoch (as used by gmtime).\n"
15316 " f: Always use fixed point numeric labels.\n"
15317 " g: Draws a grid at the major tick interval.\n"
15318 " h: Draws a grid at the minor tick interval.\n"
15319 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15320 " inwards.\n"
15321 " l: Labels axis logarithmically. This only affects the labels,\n"
15322 " not the data, and so it is necessary to compute the logarithms\n"
15323 " of data points before passing them to any of the drawing\n"
15324 " routines.\n"
15325 " m: Writes numeric labels at major tick intervals in the\n"
15326 " unconventional location (above box for X, right of box for Y).\n"
15327 " n: Writes numeric labels at major tick intervals in the\n"
15328 " conventional location (below box for X, left of box for Y).\n"
15329 " o: Use custom labelling function to generate axis label text.\n"
15330 " The custom labelling function can be defined with the\n"
15331 " plslabelfunc command.\n"
15332 " s: Enables subticks between major ticks, only valid if t is\n"
15333 " also specified.\n"
15334 " t: Draws major ticks.\n"
15335 " u: Exactly like \"b\" except don't draw edge line.\n"
15336 " w: Exactly like \"c\" except don't draw edge line.\n"
15337 " x: Exactly like \"t\" (including the side effect of the\n"
15338 " numerical labels for the major ticks) except exclude drawing\n"
15339 " the major and minor tick marks.\n"
15340 "\n"
15341 "\n"
15342 " xtick (PLFLT, input) : World coordinate interval between major\n"
15343 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15344 " generates a suitable tick interval.\n"
15345 "\n"
15346 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15347 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15348 " generates a suitable minor tick interval.\n"
15349 "\n"
15350 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15351 " options for the y axis. The string can include any combination of\n"
15352 " the letters defined above for xopt, and in addition may contain:\n"
15353 " v: Write numeric labels for the y axis parallel to the base of the\n"
15354 " graph, rather than parallel to the axis.\n"
15355 "\n"
15356 "\n"
15357 " ytick (PLFLT, input) : World coordinate interval between major\n"
15358 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15359 " generates a suitable tick interval.\n"
15360 "\n"
15361 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15362 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15363 " generates a suitable minor tick interval.\n"
15364 "\n"
15365 ""},
15366 { "plbox3", _wrap_plbox3, METH_VARARGS, "\n"
15367 "Draw a box with axes, etc, in 3-d\n"
15368 "\n"
15369 "DESCRIPTION:\n"
15370 "\n"
15371 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15372 " plot. For a more complete description of three-dimensional plotting\n"
15373 " see the PLplot documentation.\n"
15374 "\n"
15375 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15376 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15377 "\n"
15378 "\n"
15379 " This function is used in examples 8, 11, 18, and 21.\n"
15380 "\n"
15381 "\n"
15382 "\n"
15383 "SYNOPSIS:\n"
15384 "\n"
15385 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15386 "\n"
15387 "ARGUMENTS:\n"
15388 "\n"
15389 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15390 " options for the x axis. The string can include any combination of\n"
15391 " the following letters (upper or lower case) in any order: b: Draws\n"
15392 " axis at base, at height z=\n"
15393 " zmin where zmin is defined by call to plw3d. This character must be\n"
15394 " specified in order to use any of the other options.\n"
15395 " d: Plot labels as date / time. Values are assumed to be\n"
15396 " seconds since the epoch (as used by gmtime).\n"
15397 " f: Always use fixed point numeric labels.\n"
15398 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15399 " than upwards.\n"
15400 " l: Labels axis logarithmically. This only affects the labels,\n"
15401 " not the data, and so it is necessary to compute the logarithms\n"
15402 " of data points before passing them to any of the drawing\n"
15403 " routines.\n"
15404 " n: Writes numeric labels at major tick intervals.\n"
15405 " o: Use custom labelling function to generate axis label text.\n"
15406 " The custom labelling function can be defined with the\n"
15407 " plslabelfunc command.\n"
15408 " s: Enables subticks between major ticks, only valid if t is\n"
15409 " also specified.\n"
15410 " t: Draws major ticks.\n"
15411 " u: If this is specified, the text label for the axis is\n"
15412 " written under the axis.\n"
15413 "\n"
15414 "\n"
15415 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15416 " the text label for the x axis. It is only drawn if u is in the\n"
15417 " xopt string.\n"
15418 "\n"
15419 " xtick (PLFLT, input) : World coordinate interval between major\n"
15420 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15421 " generates a suitable tick interval.\n"
15422 "\n"
15423 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15424 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15425 " generates a suitable minor tick interval.\n"
15426 "\n"
15427 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15428 " options for the y axis. The string is interpreted in the same way\n"
15429 " as xopt.\n"
15430 "\n"
15431 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15432 " the text label for the y axis. It is only drawn if u is in the\n"
15433 " yopt string.\n"
15434 "\n"
15435 " ytick (PLFLT, input) : World coordinate interval between major\n"
15436 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15437 " generates a suitable tick interval.\n"
15438 "\n"
15439 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15440 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15441 " generates a suitable minor tick interval.\n"
15442 "\n"
15443 " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15444 " options for the z axis. The string can include any combination of\n"
15445 " the following letters (upper or lower case) in any order: b: Draws\n"
15446 " z axis to the left of the surface plot.\n"
15447 " c: Draws z axis to the right of the surface plot.\n"
15448 " d: Draws grid lines parallel to the x-y plane behind the\n"
15449 " figure. These lines are not drawn until after plot3d or\n"
15450 " plmesh are called because of the need for hidden line removal.\n"
15451 " e: Plot labels as date / time. Values are assumed to be\n"
15452 " seconds since the epoch (as used by gmtime). Note this\n"
15453 " suboption is interpreted the same as the d suboption for xopt\n"
15454 " and yopt, but it has to be identified as e for zopt since d\n"
15455 " has already been used for the different purpose above.\n"
15456 " f: Always use fixed point numeric labels.\n"
15457 " i: Inverts tick marks, so they are drawn away from the center.\n"
15458 " l: Labels axis logarithmically. This only affects the labels,\n"
15459 " not the data, and so it is necessary to compute the logarithms\n"
15460 " of data points before passing them to any of the drawing\n"
15461 " routines.\n"
15462 " m: Writes numeric labels at major tick intervals on the\n"
15463 " right-hand z axis.\n"
15464 " n: Writes numeric labels at major tick intervals on the\n"
15465 " left-hand z axis.\n"
15466 " o: Use custom labelling function to generate axis label text.\n"
15467 " The custom labelling function can be defined with the\n"
15468 " plslabelfunc command.\n"
15469 " s: Enables subticks between major ticks, only valid if t is\n"
15470 " also specified.\n"
15471 " t: Draws major ticks.\n"
15472 " u: If this is specified, the text label is written beside the\n"
15473 " left-hand axis.\n"
15474 " v: If this is specified, the text label is written beside the\n"
15475 " right-hand axis.\n"
15476 "\n"
15477 "\n"
15478 " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15479 " the text label for the z axis. It is only drawn if u or v are in\n"
15480 " the zopt string.\n"
15481 "\n"
15482 " ztick (PLFLT, input) : World coordinate interval between major\n"
15483 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15484 " generates a suitable tick interval.\n"
15485 "\n"
15486 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15487 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15488 " generates a suitable minor tick interval.\n"
15489 "\n"
15490 ""},
15491 { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, "\n"
15492 "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15493 "\n"
15494 "DESCRIPTION:\n"
15495 "\n"
15496 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15497 " from relative device coordinates, rx and ry.\n"
15498 "\n"
15499 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15500 "\n"
15501 "\n"
15502 " This function is used in example 31.\n"
15503 "\n"
15504 "\n"
15505 "\n"
15506 "SYNOPSIS:\n"
15507 "\n"
15508 "plcalc_world(rx, ry, wx, wy, window)\n"
15509 "\n"
15510 "ARGUMENTS:\n"
15511 "\n"
15512 " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15513 " the x coordinate.\n"
15514 "\n"
15515 " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15516 " the y coordinate.\n"
15517 "\n"
15518 " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15519 " coordinate corresponding to the relative device coordinates rx and\n"
15520 " ry.\n"
15521 "\n"
15522 " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15523 " coordinate corresponding to the relative device coordinates rx and\n"
15524 " ry.\n"
15525 "\n"
15526 " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15527 " defined window index that corresponds to the input relative device\n"
15528 " coordinates (and the returned world coordinates). To give some\n"
15529 " background on the window index, for each page the initial window\n"
15530 " index is set to zero, and each time plwind is called within the\n"
15531 " page, world and device coordinates are stored for the window and\n"
15532 " the window index is incremented. Thus, for a simple page layout\n"
15533 " with non-overlapping viewports and one window per viewport, window\n"
15534 " corresponds to the viewport index (in the order which the\n"
15535 " viewport/windows were created) of the only viewport/window\n"
15536 " corresponding to rx and ry. However, for more complicated layouts\n"
15537 " with potentially overlapping viewports and possibly more than one\n"
15538 " window (set of world coordinates) per viewport, window and the\n"
15539 " corresponding output world coordinates corresponds to the last\n"
15540 " window created that fulfills the criterion that the relative\n"
15541 " device coordinates are inside it. Finally, in all cases where the\n"
15542 " input relative device coordinates are not inside any\n"
15543 " viewport/window, then the returned value of the last defined\n"
15544 " window index is set to -1.\n"
15545 "\n"
15546 ""},
15547 { "plclear", _wrap_plclear, METH_NOARGS, "\n"
15548 "Clear current (sub)page\n"
15549 "\n"
15550 "DESCRIPTION:\n"
15551 "\n"
15552 " Clears the current page, effectively erasing everything that have been\n"
15553 " drawn. This command only works with interactive drivers; if the\n"
15554 " driver does not support this, the page is filled with the background\n"
15555 " color in use. If the current page is divided into subpages, only the\n"
15556 " current subpage is erased. The nth subpage can be selected with\n"
15557 " pladv(n).\n"
15558 "\n"
15559 " Redacted form: General: plclear()\n"
15560 "\n"
15561 "\n"
15562 " This function is not used in any examples.\n"
15563 "\n"
15564 "\n"
15565 "\n"
15566 "SYNOPSIS:\n"
15567 "\n"
15568 "plclear()\n"
15569 "\n"
15570 ""},
15571 { "plcol0", _wrap_plcol0, METH_O, "\n"
15572 "Set color, cmap0\n"
15573 "\n"
15574 "DESCRIPTION:\n"
15575 "\n"
15576 " Sets the color index for cmap0 (see the PLplot documentation).\n"
15577 "\n"
15578 " Redacted form: plcol0(icol0)\n"
15579 "\n"
15580 " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
15581 "\n"
15582 "\n"
15583 "\n"
15584 "SYNOPSIS:\n"
15585 "\n"
15586 "plcol0(icol0)\n"
15587 "\n"
15588 "ARGUMENTS:\n"
15589 "\n"
15590 " icol0 (PLINT, input) : Integer representing the color. The\n"
15591 " defaults at present are (these may change):\n"
15592 " 0 black (default background)\n"
15593 " 1 red (default foreground)\n"
15594 " 2 yellow\n"
15595 " 3 green\n"
15596 " 4 aquamarine\n"
15597 " 5 pink\n"
15598 " 6 wheat\n"
15599 " 7 grey\n"
15600 " 8 brown\n"
15601 " 9 blue\n"
15602 " 10 BlueViolet\n"
15603 " 11 cyan\n"
15604 " 12 turquoise\n"
15605 " 13 magenta\n"
15606 " 14 salmon\n"
15607 " 15 white\n"
15608 "\n"
15609 " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
15610 " change an individual color in the cmap0 color palette.\n"
15611 "\n"
15612 ""},
15613 { "plcol1", _wrap_plcol1, METH_O, "\n"
15614 "Set color, cmap1\n"
15615 "\n"
15616 "DESCRIPTION:\n"
15617 "\n"
15618 " Sets the color for cmap1 (see the PLplot documentation).\n"
15619 "\n"
15620 " Redacted form: plcol1(col1)\n"
15621 "\n"
15622 " This function is used in examples 12 and 21.\n"
15623 "\n"
15624 "\n"
15625 "\n"
15626 "SYNOPSIS:\n"
15627 "\n"
15628 "plcol1(col1)\n"
15629 "\n"
15630 "ARGUMENTS:\n"
15631 "\n"
15632 " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
15633 " is mapped to color using the continuous cmap1 palette which by\n"
15634 " default ranges from blue to the background color to red. The\n"
15635 " cmap1 palette can also be straightforwardly changed by the user\n"
15636 " with plscmap1 or plscmap1l.\n"
15637 "\n"
15638 ""},
15639 { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, "\n"
15640 "Configure the transformation between continuous and broken-down time for the current stream\n"
15641 "\n"
15642 "DESCRIPTION:\n"
15643 "\n"
15644 " Configure the transformation between continuous and broken-down time\n"
15645 " for the current stream. This transformation is used by both plbtime\n"
15646 " and plctime.\n"
15647 "\n"
15648 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
15649 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15650 "\n"
15651 "\n"
15652 " This function is used in example 29.\n"
15653 "\n"
15654 "\n"
15655 "\n"
15656 "SYNOPSIS:\n"
15657 "\n"
15658 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
15659 "\n"
15660 "ARGUMENTS:\n"
15661 "\n"
15662 " scale (PLFLT, input) : The number of days per continuous time unit.\n"
15663 " As a special case, if\n"
15664 " scale is 0., then all other arguments are ignored, and the result (the\n"
15665 " default used by PLplot) is the equivalent of a call to\n"
15666 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
15667 " That is, for this special case broken-down time is calculated with\n"
15668 " the proleptic Gregorian calendar with no leap seconds inserted,\n"
15669 " and the continuous time is defined as the number of seconds since\n"
15670 " the Unix epoch of 1970-01-01T00:00:00Z.\n"
15671 "\n"
15672 " offset1 (PLFLT, input) : If\n"
15673 " ifbtime_offset is true, the parameters\n"
15674 " offset1 and\n"
15675 " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
15676 " (with units in days) specify the epoch of the continuous time\n"
15677 " relative to the MJD epoch corresponding to the Gregorian calendar\n"
15678 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
15679 " are used to specify the origin to allow users (by specifying\n"
15680 " offset1 as an integer that can be exactly represented by a\n"
15681 " floating-point variable and specifying\n"
15682 " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
15683 " the numerical errors of the continuous time representation.\n"
15684 "\n"
15685 " offset2 (PLFLT, input) : See documentation of\n"
15686 " offset1.\n"
15687 "\n"
15688 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
15689 " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
15690 " calendar is used for broken-down time rather than the proleptic\n"
15691 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
15692 " have been historically used to define UTC are inserted into the\n"
15693 " broken-down time. Other possibilities for additional control bits\n"
15694 " for ccontrol exist such as making the historical time corrections\n"
15695 " in the broken-down time corresponding to ET (ephemeris time) or\n"
15696 " making the (slightly non-constant) corrections from international\n"
15697 " atomic time (TAI) to what astronomers define as terrestrial time\n"
15698 " (TT). But those additional possibilities have not been\n"
15699 " implemented yet in the qsastime library (one of the PLplot utility\n"
15700 " libraries).\n"
15701 "\n"
15702 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
15703 " epoch of the continuous time scale is specified by the user. If\n"
15704 " ifbtime_offset is false, then\n"
15705 " offset1 and\n"
15706 " offset2 are used to specify the epoch, and the following broken-down\n"
15707 " time parameters are completely ignored. If\n"
15708 " ifbtime_offset is true, then\n"
15709 " offset1 and\n"
15710 " offset2 are completely ignored, and the following broken-down time\n"
15711 " parameters are used to specify the epoch.\n"
15712 "\n"
15713 " year (PLINT, input) : Year of epoch.\n"
15714 "\n"
15715 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
15716 " 11 (December).\n"
15717 "\n"
15718 " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
15719 "\n"
15720 " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
15721 "\n"
15722 " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
15723 "\n"
15724 " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
15725 "\n"
15726 ""},
15727 { "plcont", _wrap_plcont, METH_VARARGS, "\n"
15728 "Contour plot\n"
15729 "\n"
15730 "DESCRIPTION:\n"
15731 "\n"
15732 " Draws a contour plot of the data in f[\n"
15733 " nx][\n"
15734 " ny], using the nlevel contour levels specified by clevel. Only the\n"
15735 " region of the matrix from kx to lx and from ky to ly is plotted out\n"
15736 " where all these index ranges are interpreted as one-based for\n"
15737 " historical reasons. A transformation routine pointed to by pltr with\n"
15738 " a generic pointer pltr_data for additional data required by the\n"
15739 " transformation routine is used to map indices within the matrix to the\n"
15740 " world coordinates.\n"
15741 "\n"
15742 " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
15743 " where (see above discussion) the pltr, pltr_data callback arguments\n"
15744 " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
15745 " vectors; or xg and yg matrices.\n"
15746 "\n"
15747 " This function is used in examples 9, 14, 16, and 22.\n"
15748 "\n"
15749 "\n"
15750 "\n"
15751 "SYNOPSIS:\n"
15752 "\n"
15753 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
15754 "\n"
15755 "ARGUMENTS:\n"
15756 "\n"
15757 " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
15758 "\n"
15759 " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
15760 "\n"
15761 " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
15762 " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
15763 " zero-based for historical backwards-compatibility reasons.\n"
15764 "\n"
15765 " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
15766 " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
15767 " zero-based for historical backwards-compatibility reasons.\n"
15768 "\n"
15769 " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
15770 " which to draw contours.\n"
15771 "\n"
15772 " nlevel (PLINT, input) : Number of contour levels to draw.\n"
15773 "\n"
15774 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
15775 " defines the transformation between the zero-based indices of the\n"
15776 " matrix f and the world coordinates.For the C case, transformation\n"
15777 " functions are provided in the PLplot library: pltr0 for the\n"
15778 " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
15779 " respectively defined by vectors and matrices. In addition, C\n"
15780 " callback routines for the transformation can be supplied by the\n"
15781 " user such as the mypltr function in examples/c/x09c.c which\n"
15782 " provides a general linear transformation between index coordinates\n"
15783 " and world coordinates.For languages other than C you should\n"
15784 " consult the PLplot documentation for the details concerning how\n"
15785 " PLTRANSFORM_callback arguments are interfaced. However, in\n"
15786 " general, a particular pattern of callback-associated arguments\n"
15787 " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
15788 " yg matrices are respectively interfaced to a linear-transformation\n"
15789 " routine similar to the above mypltr function; pltr1; and pltr2.\n"
15790 " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
15791 " the PLplot documentation) support native language callbacks for\n"
15792 " handling index to world-coordinate transformations. Examples of\n"
15793 " these various approaches are given in examples/<language>x09*,\n"
15794 " examples/<language>x16*, examples/<language>x20*,\n"
15795 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
15796 " supported languages.\n"
15797 "\n"
15798 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
15799 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
15800 " that is externally supplied.\n"
15801 "\n"
15802 ""},
15803 { "plctime", _wrap_plctime, METH_VARARGS, "\n"
15804 "Calculate continuous time from broken-down time for the current stream\n"
15805 "\n"
15806 "DESCRIPTION:\n"
15807 "\n"
15808 " Calculate continuous time, ctime, from broken-down time for the\n"
15809 " current stream. The broken-down\n"
15810 " time is specified by the following parameters: year, month, day, hour,\n"
15811 " min, and sec. This function is the inverse of plbtime.\n"
15812 "\n"
15813 " The PLplot definition of broken-down time is a calendar time that\n"
15814 " completely ignores all time zone offsets, i.e., it is the user's\n"
15815 " responsibility to apply those offsets (if so desired) before using the\n"
15816 " PLplot time API. By default broken-down time is defined using the\n"
15817 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15818 " continuous time is defined as the number of seconds since the Unix\n"
15819 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15820 " broken-down and continuous time are possible, see plconfigtime which\n"
15821 " specifies that transformation for the current stream.\n"
15822 "\n"
15823 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
15824 " ctime)\n"
15825 "\n"
15826 "\n"
15827 " This function is used in example 29.\n"
15828 "\n"
15829 "\n"
15830 "\n"
15831 "SYNOPSIS:\n"
15832 "\n"
15833 "plctime(year, month, day, hour, min, sec, ctime)\n"
15834 "\n"
15835 "ARGUMENTS:\n"
15836 "\n"
15837 " year (PLINT, input) : Input year.\n"
15838 "\n"
15839 " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
15840 " (December).\n"
15841 "\n"
15842 " day (PLINT, input) : Input day in range from 1 to 31.\n"
15843 "\n"
15844 " hour (PLINT, input) : Input hour in range from 0 to 23\n"
15845 "\n"
15846 " min (PLINT, input) : Input minute in range from 0 to 59.\n"
15847 "\n"
15848 " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
15849 "\n"
15850 " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
15851 " time calculated from the broken-down time specified by the\n"
15852 " previous parameters.\n"
15853 "\n"
15854 ""},
15855 { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, "\n"
15856 "Copy state parameters from the reference stream to the current stream\n"
15857 "\n"
15858 "DESCRIPTION:\n"
15859 "\n"
15860 " Copies state parameters from the reference stream to the current\n"
15861 " stream. Tell driver interface to map device coordinates unless flags\n"
15862 " == 1.\n"
15863 "\n"
15864 " This function is used for making save files of selected plots (e.g.\n"
15865 " from the TK driver). After initializing, you can get a copy of the\n"
15866 " current plot to the specified device by switching to this stream and\n"
15867 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
15868 " appropriate. The plot buffer must have previously been enabled (done\n"
15869 " automatically by some display drivers, such as X).\n"
15870 "\n"
15871 " Redacted form: plcpstrm(iplsr, flags)\n"
15872 "\n"
15873 " This function is used in example 1,20.\n"
15874 "\n"
15875 "\n"
15876 "\n"
15877 "SYNOPSIS:\n"
15878 "\n"
15879 "plcpstrm(iplsr, flags)\n"
15880 "\n"
15881 "ARGUMENTS:\n"
15882 "\n"
15883 " iplsr (PLINT, input) : Number of reference stream.\n"
15884 "\n"
15885 " flags (PLBOOL, input) : If flags is set to true the device\n"
15886 " coordinates are not copied from the reference to current stream.\n"
15887 "\n"
15888 ""},
15889 { "plend", _wrap_plend, METH_NOARGS, "\n"
15890 "End plotting session\n"
15891 "\n"
15892 "DESCRIPTION:\n"
15893 "\n"
15894 " Ends a plotting session, tidies up all the output files, switches\n"
15895 " interactive devices back into text mode and frees up any memory that\n"
15896 " was allocated. Must be called before end of program.\n"
15897 "\n"
15898 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
15899 " wait state after a call to plend or other functions which trigger the\n"
15900 " end of a plot page. To avoid this, use the plspause function.\n"
15901 "\n"
15902 " Redacted form: plend()\n"
15903 "\n"
15904 " This function is used in all of the examples.\n"
15905 "\n"
15906 "\n"
15907 "\n"
15908 "SYNOPSIS:\n"
15909 "\n"
15910 "plend()\n"
15911 "\n"
15912 ""},
15913 { "plend1", _wrap_plend1, METH_NOARGS, "\n"
15914 "End plotting session for current stream\n"
15915 "\n"
15916 "DESCRIPTION:\n"
15917 "\n"
15918 " Ends a plotting session for the current output stream only. See\n"
15919 " plsstrm for more info.\n"
15920 "\n"
15921 " Redacted form: plend1()\n"
15922 "\n"
15923 " This function is used in examples 1 and 20.\n"
15924 "\n"
15925 "\n"
15926 "\n"
15927 "SYNOPSIS:\n"
15928 "\n"
15929 "plend1()\n"
15930 "\n"
15931 ""},
15932 { "plenv", _wrap_plenv, METH_VARARGS, "\n"
15933 "Set up standard window and draw box\n"
15934 "\n"
15935 "DESCRIPTION:\n"
15936 "\n"
15937 " Sets up plotter environment for simple graphs by calling pladv and\n"
15938 " setting up viewport and window to sensible default values. plenv\n"
15939 " leaves a standard margin (left-hand margin of eight character heights,\n"
15940 " and a margin around the other three sides of five character heights)\n"
15941 " around most graphs for axis labels and a title. When these defaults\n"
15942 " are not suitable, use the individual routines plvpas, plvpor, or\n"
15943 " plvasp for setting up the viewport, plwind for defining the window,\n"
15944 " and plbox for drawing the box.\n"
15945 "\n"
15946 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15947 "\n"
15948 " This function is used in example 1,3,9,13,14,19-22,29.\n"
15949 "\n"
15950 "\n"
15951 "\n"
15952 "SYNOPSIS:\n"
15953 "\n"
15954 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
15955 "\n"
15956 "ARGUMENTS:\n"
15957 "\n"
15958 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
15959 " world coordinates).\n"
15960 "\n"
15961 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
15962 " world coordinates).\n"
15963 "\n"
15964 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
15965 " coordinates).\n"
15966 "\n"
15967 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
15968 " coordinates).\n"
15969 "\n"
15970 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
15971 " scales will not be set, the user must set up the scale before\n"
15972 " calling plenv using plsvpa, plvasp or other.\n"
15973 " 0: the x and y axes are scaled independently to use as much of\n"
15974 " the screen as possible.\n"
15975 " 1: the scales of the x and y axes are made equal.\n"
15976 " 2: the axis of the x and y axes are made equal, and the plot\n"
15977 " box will be square.\n"
15978 "\n"
15979 "\n"
15980 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
15981 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
15982 " -1: draw box only.\n"
15983 " 0: draw box, ticks, and numeric tick labels.\n"
15984 " 1: also draw coordinate axes at x=0 and y=0.\n"
15985 " 2: also draw a grid at major tick positions in both\n"
15986 " coordinates.\n"
15987 " 3: also draw a grid at minor tick positions in both\n"
15988 " coordinates.\n"
15989 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
15990 " have to be converted to logarithms separately.)\n"
15991 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
15992 " have to be converted to logarithms separately.)\n"
15993 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
15994 " have to be converted to logarithms separately.)\n"
15995 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
15996 " have to be converted to logarithms separately.)\n"
15997 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
15998 " have to be converted to logarithms separately.)\n"
15999 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16000 " have to be converted to logarithms separately.)\n"
16001 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16002 " have to be converted to logarithms separately.)\n"
16003 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16004 " have to be converted to logarithms separately.)\n"
16005 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16006 " and y data have to be converted to logarithms separately.)\n"
16007 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16008 " and y data have to be converted to logarithms separately.)\n"
16009 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16010 " and y data have to be converted to logarithms separately.)\n"
16011 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16012 " and y data have to be converted to logarithms separately.)\n"
16013 " 40: same as 0 except date / time x labels.\n"
16014 " 41: same as 1 except date / time x labels.\n"
16015 " 42: same as 2 except date / time x labels.\n"
16016 " 43: same as 3 except date / time x labels.\n"
16017 " 50: same as 0 except date / time y labels.\n"
16018 " 51: same as 1 except date / time y labels.\n"
16019 " 52: same as 2 except date / time y labels.\n"
16020 " 53: same as 3 except date / time y labels.\n"
16021 " 60: same as 0 except date / time x and y labels.\n"
16022 " 61: same as 1 except date / time x and y labels.\n"
16023 " 62: same as 2 except date / time x and y labels.\n"
16024 " 63: same as 3 except date / time x and y labels.\n"
16025 " 70: same as 0 except custom x and y labels.\n"
16026 " 71: same as 1 except custom x and y labels.\n"
16027 " 72: same as 2 except custom x and y labels.\n"
16028 " 73: same as 3 except custom x and y labels.\n"
16029 "\n"
16030 ""},
16031 { "plenv0", _wrap_plenv0, METH_VARARGS, "\n"
16032 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16033 "\n"
16034 "DESCRIPTION:\n"
16035 "\n"
16036 " Sets up plotter environment for simple graphs by calling pladv and\n"
16037 " setting up viewport and window to sensible default values. plenv0\n"
16038 " leaves a standard margin (left-hand margin of eight character heights,\n"
16039 " and a margin around the other three sides of five character heights)\n"
16040 " around most graphs for axis labels and a title. When these defaults\n"
16041 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16042 " plvasp for setting up the viewport, plwind for defining the window,\n"
16043 " and plbox for drawing the box.\n"
16044 "\n"
16045 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16046 "\n"
16047 " This function is used in example 21.\n"
16048 "\n"
16049 "\n"
16050 "\n"
16051 "SYNOPSIS:\n"
16052 "\n"
16053 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16054 "\n"
16055 "ARGUMENTS:\n"
16056 "\n"
16057 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16058 " world coordinates).\n"
16059 "\n"
16060 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16061 " world coordinates).\n"
16062 "\n"
16063 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16064 " coordinates).\n"
16065 "\n"
16066 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16067 " coordinates).\n"
16068 "\n"
16069 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16070 " scales will not be set, the user must set up the scale before\n"
16071 " calling plenv0 using plsvpa, plvasp or other.\n"
16072 " 0: the x and y axes are scaled independently to use as much of\n"
16073 " the screen as possible.\n"
16074 " 1: the scales of the x and y axes are made equal.\n"
16075 " 2: the axis of the x and y axes are made equal, and the plot\n"
16076 " box will be square.\n"
16077 "\n"
16078 "\n"
16079 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16080 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16081 " -1: draw box only.\n"
16082 " 0: draw box, ticks, and numeric tick labels.\n"
16083 " 1: also draw coordinate axes at x=0 and y=0.\n"
16084 " 2: also draw a grid at major tick positions in both\n"
16085 " coordinates.\n"
16086 " 3: also draw a grid at minor tick positions in both\n"
16087 " coordinates.\n"
16088 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16089 " have to be converted to logarithms separately.)\n"
16090 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16091 " have to be converted to logarithms separately.)\n"
16092 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16093 " have to be converted to logarithms separately.)\n"
16094 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16095 " have to be converted to logarithms separately.)\n"
16096 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16097 " have to be converted to logarithms separately.)\n"
16098 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16099 " have to be converted to logarithms separately.)\n"
16100 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16101 " have to be converted to logarithms separately.)\n"
16102 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16103 " have to be converted to logarithms separately.)\n"
16104 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16105 " and y data have to be converted to logarithms separately.)\n"
16106 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16107 " and y data have to be converted to logarithms separately.)\n"
16108 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16109 " and y data have to be converted to logarithms separately.)\n"
16110 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16111 " and y data have to be converted to logarithms separately.)\n"
16112 " 40: same as 0 except date / time x labels.\n"
16113 " 41: same as 1 except date / time x labels.\n"
16114 " 42: same as 2 except date / time x labels.\n"
16115 " 43: same as 3 except date / time x labels.\n"
16116 " 50: same as 0 except date / time y labels.\n"
16117 " 51: same as 1 except date / time y labels.\n"
16118 " 52: same as 2 except date / time y labels.\n"
16119 " 53: same as 3 except date / time y labels.\n"
16120 " 60: same as 0 except date / time x and y labels.\n"
16121 " 61: same as 1 except date / time x and y labels.\n"
16122 " 62: same as 2 except date / time x and y labels.\n"
16123 " 63: same as 3 except date / time x and y labels.\n"
16124 " 70: same as 0 except custom x and y labels.\n"
16125 " 71: same as 1 except custom x and y labels.\n"
16126 " 72: same as 2 except custom x and y labels.\n"
16127 " 73: same as 3 except custom x and y labels.\n"
16128 "\n"
16129 ""},
16130 { "pleop", _wrap_pleop, METH_NOARGS, "\n"
16131 "Eject current page\n"
16132 "\n"
16133 "DESCRIPTION:\n"
16134 "\n"
16135 " Clears the graphics screen of an interactive device, or ejects a page\n"
16136 " on a plotter. See plbop for more information.\n"
16137 "\n"
16138 " Redacted form: pleop()\n"
16139 "\n"
16140 " This function is used in example 2,14.\n"
16141 "\n"
16142 "\n"
16143 "\n"
16144 "SYNOPSIS:\n"
16145 "\n"
16146 "pleop()\n"
16147 "\n"
16148 ""},
16149 { "plerrx", _wrap_plerrx, METH_VARARGS, "\n"
16150 "Draw error bars in x direction\n"
16151 "\n"
16152 "DESCRIPTION:\n"
16153 "\n"
16154 " Draws a set of n error bars in x direction, the i'th error bar\n"
16155 " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16156 " of the error bars are of length equal to the minor tick length\n"
16157 " (settable using plsmin).\n"
16158 "\n"
16159 " Redacted form: General: plerrx(xmin, ymax, y)\n"
16160 "\n"
16161 "\n"
16162 " This function is used in example 29.\n"
16163 "\n"
16164 "\n"
16165 "\n"
16166 "SYNOPSIS:\n"
16167 "\n"
16168 "plerrx(n, xmin, xmax, y)\n"
16169 "\n"
16170 "ARGUMENTS:\n"
16171 "\n"
16172 " n (PLINT, input) : Number of error bars to draw.\n"
16173 "\n"
16174 " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16175 " of the left-hand endpoints of the error bars.\n"
16176 "\n"
16177 " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16178 " of the right-hand endpoints of the error bars.\n"
16179 "\n"
16180 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16181 " the error bars.\n"
16182 "\n"
16183 ""},
16184 { "plerry", _wrap_plerry, METH_VARARGS, "\n"
16185 "Draw error bars in the y direction\n"
16186 "\n"
16187 "DESCRIPTION:\n"
16188 "\n"
16189 " Draws a set of n error bars in the y direction, the i'th error bar\n"
16190 " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16191 " of the error bars are of length equal to the minor tick length\n"
16192 " (settable using plsmin).\n"
16193 "\n"
16194 " Redacted form: General: plerry(x, ymin, ymax)\n"
16195 "\n"
16196 "\n"
16197 " This function is used in example 29.\n"
16198 "\n"
16199 "\n"
16200 "\n"
16201 "SYNOPSIS:\n"
16202 "\n"
16203 "plerry(n, x, ymin, ymax)\n"
16204 "\n"
16205 "ARGUMENTS:\n"
16206 "\n"
16207 " n (PLINT, input) : Number of error bars to draw.\n"
16208 "\n"
16209 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16210 " the error bars.\n"
16211 "\n"
16212 " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16213 " of the lower endpoints of the error bars.\n"
16214 "\n"
16215 " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16216 " of the upper endpoints of the error bars.\n"
16217 "\n"
16218 ""},
16219 { "plfamadv", _wrap_plfamadv, METH_NOARGS, "\n"
16220 "Advance to the next family file on the next new page\n"
16221 "\n"
16222 "DESCRIPTION:\n"
16223 "\n"
16224 " Advance to the next family file on the next new page.\n"
16225 "\n"
16226 " Redacted form: plfamadv()\n"
16227 "\n"
16228 " This function is not used in any examples.\n"
16229 "\n"
16230 "\n"
16231 "\n"
16232 "SYNOPSIS:\n"
16233 "\n"
16234 "plfamadv()\n"
16235 "\n"
16236 ""},
16237 { "plfill", _wrap_plfill, METH_VARARGS, "\n"
16238 "Draw filled polygon\n"
16239 "\n"
16240 "DESCRIPTION:\n"
16241 "\n"
16242 " Fills the polygon defined by the n points (\n"
16243 " x[i],\n"
16244 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16245 " style is a solid fill. The routine will automatically close the\n"
16246 " polygon between the last and first vertices. If multiple closed\n"
16247 " polygons are passed in x and y then plfill will fill in between them.\n"
16248 "\n"
16249 " Redacted form: plfill(x,y)\n"
16250 "\n"
16251 " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16252 "\n"
16253 "\n"
16254 "\n"
16255 "SYNOPSIS:\n"
16256 "\n"
16257 "plfill(n, x, y)\n"
16258 "\n"
16259 "ARGUMENTS:\n"
16260 "\n"
16261 " n (PLINT, input) : Number of vertices in polygon.\n"
16262 "\n"
16263 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16264 " vertices.\n"
16265 "\n"
16266 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16267 " vertices.\n"
16268 "\n"
16269 ""},
16270 { "plfill3", _wrap_plfill3, METH_VARARGS, "\n"
16271 "Draw filled polygon in 3D\n"
16272 "\n"
16273 "DESCRIPTION:\n"
16274 "\n"
16275 " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16276 " vectors using the pattern defined by plpsty or plpat. The routine\n"
16277 " will automatically close the polygon between the last and first\n"
16278 " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16279 " plfill3 will fill in between them.\n"
16280 "\n"
16281 " Redacted form: General: plfill3(x, y, z)\n"
16282 "\n"
16283 "\n"
16284 " This function is used in example 15.\n"
16285 "\n"
16286 "\n"
16287 "\n"
16288 "SYNOPSIS:\n"
16289 "\n"
16290 "plfill3(n, x, y, z)\n"
16291 "\n"
16292 "ARGUMENTS:\n"
16293 "\n"
16294 " n (PLINT, input) : Number of vertices in polygon.\n"
16295 "\n"
16296 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16297 " vertices.\n"
16298 "\n"
16299 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16300 " vertices.\n"
16301 "\n"
16302 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16303 " vertices.\n"
16304 "\n"
16305 ""},
16306 { "plgradient", _wrap_plgradient, METH_VARARGS, "\n"
16307 "Draw linear gradient inside polygon\n"
16308 "\n"
16309 "DESCRIPTION:\n"
16310 "\n"
16311 " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16312 " points (\n"
16313 " x[i],\n"
16314 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16315 " polygon coordinates and the gradient angle are all expressed in world\n"
16316 " coordinates. The angle from the x axis for both the rotated\n"
16317 " coordinate system and the gradient vector is specified by angle. The\n"
16318 " magnitude of the gradient vector is the difference between the maximum\n"
16319 " and minimum values of x for the vertices in the rotated coordinate\n"
16320 " system. The origin of the gradient vector can be interpreted as being\n"
16321 " anywhere on the line corresponding to the minimum x value for the\n"
16322 " vertices in the rotated coordinate system. The distance along the\n"
16323 " gradient vector is linearly transformed to the independent variable of\n"
16324 " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16325 " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16326 " color corresponding to the independent variable of cmap1. For more\n"
16327 " information about cmap1 (see the PLplot documentation).\n"
16328 "\n"
16329 " Redacted form: plgradient(x,y,angle)\n"
16330 "\n"
16331 " This function is used in examples 25 and 30.\n"
16332 "\n"
16333 "\n"
16334 "\n"
16335 "SYNOPSIS:\n"
16336 "\n"
16337 "plgradient(n, x, y, angle)\n"
16338 "\n"
16339 "ARGUMENTS:\n"
16340 "\n"
16341 " n (PLINT, input) : Number of vertices in polygon.\n"
16342 "\n"
16343 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16344 " vertices.\n"
16345 "\n"
16346 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16347 " vertices.\n"
16348 "\n"
16349 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16350 " axis.\n"
16351 "\n"
16352 ""},
16353 { "plflush", _wrap_plflush, METH_NOARGS, "\n"
16354 "Flushes the output stream\n"
16355 "\n"
16356 "DESCRIPTION:\n"
16357 "\n"
16358 " Flushes the output stream. Use sparingly, if at all.\n"
16359 "\n"
16360 " Redacted form: plflush()\n"
16361 "\n"
16362 " This function is used in examples 1 and 14.\n"
16363 "\n"
16364 "\n"
16365 "\n"
16366 "SYNOPSIS:\n"
16367 "\n"
16368 "plflush()\n"
16369 "\n"
16370 ""},
16371 { "plfont", _wrap_plfont, METH_O, "\n"
16372 "Set font\n"
16373 "\n"
16374 "DESCRIPTION:\n"
16375 "\n"
16376 " Sets the font used for subsequent text and symbols. For devices that\n"
16377 " still use Hershey fonts this routine has no effect unless the Hershey\n"
16378 " fonts with extended character set are loaded (see plfontld). For\n"
16379 " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16380 " this routine calls the plsfci routine with argument set up\n"
16381 " appropriately for the various cases below. However, this method of\n"
16382 " specifying the font for unicode-aware devices is deprecated, and the\n"
16383 " much more flexible method of calling plsfont directly is recommended\n"
16384 " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16385 "\n"
16386 " Redacted form: plfont(ifont)\n"
16387 "\n"
16388 " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16389 "\n"
16390 "\n"
16391 "\n"
16392 "SYNOPSIS:\n"
16393 "\n"
16394 "plfont(ifont)\n"
16395 "\n"
16396 "ARGUMENTS:\n"
16397 "\n"
16398 " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16399 " (simplest and fastest)\n"
16400 " 2: Serif font\n"
16401 " 3: Italic font\n"
16402 " 4: Script font\n"
16403 "\n"
16404 ""},
16405 { "plfontld", _wrap_plfontld, METH_O, "\n"
16406 "Load Hershey fonts\n"
16407 "\n"
16408 "DESCRIPTION:\n"
16409 "\n"
16410 " Loads the Hershey fonts used for text and symbols. This routine may\n"
16411 " be called before or after initializing PLplot. If not explicitly\n"
16412 " called before PLplot initialization, then by default that\n"
16413 " initialization loads Hershey fonts with the extended character set.\n"
16414 " This routine only has a practical effect for devices that still use\n"
16415 " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16416 " system fonts instead of Hershey fonts).\n"
16417 "\n"
16418 " Redacted form: plfontld(fnt)\n"
16419 "\n"
16420 " This function is used in examples 1 and 7.\n"
16421 "\n"
16422 "\n"
16423 "\n"
16424 "SYNOPSIS:\n"
16425 "\n"
16426 "plfontld(fnt)\n"
16427 "\n"
16428 "ARGUMENTS:\n"
16429 "\n"
16430 " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16431 " A zero value specifies Hershey fonts with the standard character\n"
16432 " set and a non-zero value (the default assumed if plfontld is never\n"
16433 " called) specifies Hershey fonts with the extended character set.\n"
16434 "\n"
16435 ""},
16436 { "plgchr", _wrap_plgchr, METH_NOARGS, "\n"
16437 "Get character default height and current (scaled) height\n"
16438 "\n"
16439 "DESCRIPTION:\n"
16440 "\n"
16441 " Get character default height and current (scaled) height.\n"
16442 "\n"
16443 " Redacted form: plgchr(p_def, p_ht)\n"
16444 "\n"
16445 " This function is used in example 23.\n"
16446 "\n"
16447 "\n"
16448 "\n"
16449 "SYNOPSIS:\n"
16450 "\n"
16451 "plgchr(p_def, p_ht)\n"
16452 "\n"
16453 "ARGUMENTS:\n"
16454 "\n"
16455 " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16456 " character height (mm).\n"
16457 "\n"
16458 " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16459 " character height (mm).\n"
16460 "\n"
16461 ""},
16462 { "plgcol0", _wrap_plgcol0, METH_O, "\n"
16463 "Returns 8-bit RGB values for given color index from cmap0\n"
16464 "\n"
16465 "DESCRIPTION:\n"
16466 "\n"
16467 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16468 " PLplot documentation). Values are negative if an invalid color id is\n"
16469 " given.\n"
16470 "\n"
16471 " Redacted form: plgcol0(icol0, r, g, b)\n"
16472 "\n"
16473 " This function is used in example 2.\n"
16474 "\n"
16475 "\n"
16476 "\n"
16477 "SYNOPSIS:\n"
16478 "\n"
16479 "plgcol0(icol0, r, g, b)\n"
16480 "\n"
16481 "ARGUMENTS:\n"
16482 "\n"
16483 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16484 "\n"
16485 " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16486 " value.\n"
16487 "\n"
16488 " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16489 " value.\n"
16490 "\n"
16491 " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16492 " value.\n"
16493 "\n"
16494 ""},
16495 { "plgcol0a", _wrap_plgcol0a, METH_O, "\n"
16496 "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16497 "\n"
16498 "DESCRIPTION:\n"
16499 "\n"
16500 " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16501 " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16502 " Values are negative if an invalid color id is given.\n"
16503 "\n"
16504 " Redacted form: plgcola(r, g, b)\n"
16505 "\n"
16506 " This function is used in example 30.\n"
16507 "\n"
16508 "\n"
16509 "\n"
16510 "SYNOPSIS:\n"
16511 "\n"
16512 "plgcol0a(icol0, r, g, b, alpha)\n"
16513 "\n"
16514 "ARGUMENTS:\n"
16515 "\n"
16516 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16517 "\n"
16518 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16519 " in the range from 0 to 255.\n"
16520 "\n"
16521 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16522 " in the range from 0 to 255.\n"
16523 "\n"
16524 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16525 " in the range from 0 to 255.\n"
16526 "\n"
16527 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16528 " transparency in the range from (0.0-1.0).\n"
16529 "\n"
16530 ""},
16531 { "plgcolbg", _wrap_plgcolbg, METH_NOARGS, "\n"
16532 "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16533 "\n"
16534 "DESCRIPTION:\n"
16535 "\n"
16536 " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16537 "\n"
16538 " Redacted form: plgcolbg(r, g, b)\n"
16539 "\n"
16540 " This function is used in example 31.\n"
16541 "\n"
16542 "\n"
16543 "\n"
16544 "SYNOPSIS:\n"
16545 "\n"
16546 "plgcolbg(r, g, b)\n"
16547 "\n"
16548 "ARGUMENTS:\n"
16549 "\n"
16550 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16551 " in the range from 0 to 255.\n"
16552 "\n"
16553 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16554 " in the range from 0 to 255.\n"
16555 "\n"
16556 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16557 " in the range from 0 to 255.\n"
16558 "\n"
16559 ""},
16560 { "plgcolbga", _wrap_plgcolbga, METH_NOARGS, "\n"
16561 "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
16562 "\n"
16563 "DESCRIPTION:\n"
16564 "\n"
16565 " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
16566 " alpha transparency value.\n"
16567 "\n"
16568 " This function is used in example 31.\n"
16569 "\n"
16570 "\n"
16571 "\n"
16572 "SYNOPSIS:\n"
16573 "\n"
16574 "plgcolbga(r, g, b, alpha)\n"
16575 "\n"
16576 "ARGUMENTS:\n"
16577 "\n"
16578 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16579 " in the range from 0 to 255.\n"
16580 "\n"
16581 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16582 " in the range from 0 to 255.\n"
16583 "\n"
16584 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16585 " in the range from 0 to 255.\n"
16586 "\n"
16587 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16588 " transparency in the range (0.0-1.0).\n"
16589 "\n"
16590 ""},
16591 { "plgcompression", _wrap_plgcompression, METH_NOARGS, "\n"
16592 "Get the current device-compression setting\n"
16593 "\n"
16594 "DESCRIPTION:\n"
16595 "\n"
16596 " Get the current device-compression setting. This parameter is only\n"
16597 " used for drivers that provide compression.\n"
16598 "\n"
16599 " Redacted form: plgcompression(compression)\n"
16600 "\n"
16601 " This function is used in example 31.\n"
16602 "\n"
16603 "\n"
16604 "\n"
16605 "SYNOPSIS:\n"
16606 "\n"
16607 "plgcompression(compression)\n"
16608 "\n"
16609 "ARGUMENTS:\n"
16610 "\n"
16611 " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
16612 " compression setting for the current device.\n"
16613 "\n"
16614 ""},
16615 { "plgdev", _wrap_plgdev, METH_NOARGS, "\n"
16616 "Get the current device (keyword) name\n"
16617 "\n"
16618 "DESCRIPTION:\n"
16619 "\n"
16620 " Get the current device (keyword) name. Note: you must have allocated\n"
16621 " space for this (80 characters is safe).\n"
16622 "\n"
16623 " Redacted form: plgdev(p_dev)\n"
16624 "\n"
16625 " This function is used in example 14.\n"
16626 "\n"
16627 "\n"
16628 "\n"
16629 "SYNOPSIS:\n"
16630 "\n"
16631 "plgdev(p_dev)\n"
16632 "\n"
16633 "ARGUMENTS:\n"
16634 "\n"
16635 " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16636 " (with preallocated length of 80 characters or more) containing the\n"
16637 " device (keyword) name.\n"
16638 "\n"
16639 ""},
16640 { "plgdidev", _wrap_plgdidev, METH_NOARGS, "\n"
16641 "Get parameters that define current device-space window\n"
16642 "\n"
16643 "DESCRIPTION:\n"
16644 "\n"
16645 " Get relative margin width, aspect ratio, and relative justification\n"
16646 " that define current device-space window. If plsdidev has not been\n"
16647 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
16648 " p_jy will all be 0.\n"
16649 "\n"
16650 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16651 "\n"
16652 " This function is used in example 31.\n"
16653 "\n"
16654 "\n"
16655 "\n"
16656 "SYNOPSIS:\n"
16657 "\n"
16658 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
16659 "\n"
16660 "ARGUMENTS:\n"
16661 "\n"
16662 " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16663 " margin width.\n"
16664 "\n"
16665 " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
16666 " ratio.\n"
16667 "\n"
16668 " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16669 " justification in x.\n"
16670 "\n"
16671 " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16672 " justification in y.\n"
16673 "\n"
16674 ""},
16675 { "plgdiori", _wrap_plgdiori, METH_NOARGS, "\n"
16676 "Get plot orientation\n"
16677 "\n"
16678 "DESCRIPTION:\n"
16679 "\n"
16680 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
16681 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
16682 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
16683 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
16684 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
16685 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
16686 " not been called the default value pointed to by p_rot will be 0.\n"
16687 "\n"
16688 " Redacted form: plgdiori(p_rot)\n"
16689 "\n"
16690 " This function is not used in any examples.\n"
16691 "\n"
16692 "\n"
16693 "\n"
16694 "SYNOPSIS:\n"
16695 "\n"
16696 "plgdiori(p_rot)\n"
16697 "\n"
16698 "ARGUMENTS:\n"
16699 "\n"
16700 " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
16701 " parameter.\n"
16702 "\n"
16703 ""},
16704 { "plgdiplt", _wrap_plgdiplt, METH_NOARGS, "\n"
16705 "Get parameters that define current plot-space window\n"
16706 "\n"
16707 "DESCRIPTION:\n"
16708 "\n"
16709 " Get relative minima and maxima that define current plot-space window.\n"
16710 " If plsdiplt has not been called the default values pointed to by\n"
16711 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
16712 "\n"
16713 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16714 "\n"
16715 " This function is used in example 31.\n"
16716 "\n"
16717 "\n"
16718 "\n"
16719 "SYNOPSIS:\n"
16720 "\n"
16721 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
16722 "\n"
16723 "ARGUMENTS:\n"
16724 "\n"
16725 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16726 " minimum in x.\n"
16727 "\n"
16728 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16729 " minimum in y.\n"
16730 "\n"
16731 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16732 " maximum in x.\n"
16733 "\n"
16734 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
16735 " maximum in y.\n"
16736 "\n"
16737 ""},
16738 { "plgfam", _wrap_plgfam, METH_NOARGS, "\n"
16739 "Get family file parameters\n"
16740 "\n"
16741 "DESCRIPTION:\n"
16742 "\n"
16743 " Gets information about current family file, if familying is enabled.\n"
16744 " See the PLplot documentation for more information.\n"
16745 "\n"
16746 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
16747 "\n"
16748 " This function is used in examples 14 and 31.\n"
16749 "\n"
16750 "\n"
16751 "\n"
16752 "SYNOPSIS:\n"
16753 "\n"
16754 "plgfam(p_fam, p_num, p_bmax)\n"
16755 "\n"
16756 "ARGUMENTS:\n"
16757 "\n"
16758 " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16759 " family flag value. If nonzero, familying is enabled for the\n"
16760 " current device.\n"
16761 "\n"
16762 " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16763 " family file number.\n"
16764 "\n"
16765 " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
16766 " file size (in bytes) for a family file.\n"
16767 "\n"
16768 ""},
16769 { "plgfci", _wrap_plgfci, METH_NOARGS, "\n"
16770 "Get FCI (font characterization integer)\n"
16771 "\n"
16772 "DESCRIPTION:\n"
16773 "\n"
16774 " Gets information about the current font using the FCI approach. See\n"
16775 " the PLplot documentation for more information.\n"
16776 "\n"
16777 " Redacted form: plgfci(p_fci)\n"
16778 "\n"
16779 " This function is used in example 23.\n"
16780 "\n"
16781 "\n"
16782 "\n"
16783 "SYNOPSIS:\n"
16784 "\n"
16785 "plgfci(p_fci)\n"
16786 "\n"
16787 "ARGUMENTS:\n"
16788 "\n"
16789 " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
16790 " FCI value.\n"
16791 "\n"
16792 ""},
16793 { "plgfnam", _wrap_plgfnam, METH_NOARGS, "\n"
16794 "Get output file name\n"
16795 "\n"
16796 "DESCRIPTION:\n"
16797 "\n"
16798 " Gets the current output file name, if applicable.\n"
16799 "\n"
16800 " Redacted form: plgfnam(fnam)\n"
16801 "\n"
16802 " This function is used in example 31.\n"
16803 "\n"
16804 "\n"
16805 "\n"
16806 "SYNOPSIS:\n"
16807 "\n"
16808 "plgfnam(fnam)\n"
16809 "\n"
16810 "ARGUMENTS:\n"
16811 "\n"
16812 " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
16813 " (with preallocated length of 80 characters or more) containing the\n"
16814 " file name.\n"
16815 "\n"
16816 ""},
16817 { "plgfont", _wrap_plgfont, METH_NOARGS, "\n"
16818 "Get family, style and weight of the current font\n"
16819 "\n"
16820 "DESCRIPTION:\n"
16821 "\n"
16822 " Gets information about current font. See the PLplot documentation for\n"
16823 " more information on font selection.\n"
16824 "\n"
16825 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
16826 "\n"
16827 " This function is used in example 23.\n"
16828 "\n"
16829 "\n"
16830 "\n"
16831 "SYNOPSIS:\n"
16832 "\n"
16833 "plgfont(p_family, p_style, p_weight)\n"
16834 "\n"
16835 "ARGUMENTS:\n"
16836 "\n"
16837 " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16838 " font family. The available values are given by the PL_FCI_*\n"
16839 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
16840 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
16841 " p_family is NULL then the font family is not returned.\n"
16842 "\n"
16843 " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16844 " font style. The available values are given by the PL_FCI_*\n"
16845 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
16846 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
16847 " style is not returned.\n"
16848 "\n"
16849 " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
16850 " font weight. The available values are given by the PL_FCI_*\n"
16851 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
16852 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
16853 " returned.\n"
16854 "\n"
16855 ""},
16856 { "plglevel", _wrap_plglevel, METH_NOARGS, "\n"
16857 "Get the (current) run level\n"
16858 "\n"
16859 "DESCRIPTION:\n"
16860 "\n"
16861 " Get the (current) run level. Valid settings are: 0, uninitialized\n"
16862 " 1, initialized\n"
16863 " 2, viewport defined\n"
16864 " 3, world coordinates defined\n"
16865 "\n"
16866 "\n"
16867 " Redacted form: plglevel(p_level)\n"
16868 "\n"
16869 " This function is used in example 31.\n"
16870 "\n"
16871 "\n"
16872 "\n"
16873 "SYNOPSIS:\n"
16874 "\n"
16875 "plglevel(p_level)\n"
16876 "\n"
16877 "ARGUMENTS:\n"
16878 "\n"
16879 " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
16880 " level.\n"
16881 "\n"
16882 ""},
16883 { "plgpage", _wrap_plgpage, METH_NOARGS, "\n"
16884 "Get page parameters\n"
16885 "\n"
16886 "DESCRIPTION:\n"
16887 "\n"
16888 " Gets the current page configuration. The length and offset values are\n"
16889 " expressed in units that are specific to the current driver. For\n"
16890 " instance: screen drivers will usually interpret them as number of\n"
16891 " pixels, whereas printer drivers will usually use mm.\n"
16892 "\n"
16893 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
16894 "\n"
16895 " This function is used in examples 14 and 31.\n"
16896 "\n"
16897 "\n"
16898 "\n"
16899 "SYNOPSIS:\n"
16900 "\n"
16901 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
16902 "\n"
16903 "ARGUMENTS:\n"
16904 "\n"
16905 " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
16906 " pixels/inch (DPI) in x.\n"
16907 "\n"
16908 " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
16909 " pixels/inch (DPI) in y.\n"
16910 "\n"
16911 " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
16912 " length.\n"
16913 "\n"
16914 " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
16915 " length.\n"
16916 "\n"
16917 " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
16918 " offset.\n"
16919 "\n"
16920 " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
16921 " offset.\n"
16922 "\n"
16923 ""},
16924 { "plgra", _wrap_plgra, METH_NOARGS, "\n"
16925 "Switch to graphics screen\n"
16926 "\n"
16927 "DESCRIPTION:\n"
16928 "\n"
16929 " Sets an interactive device to graphics mode, used in conjunction with\n"
16930 " pltext to allow graphics and text to be interspersed. On a device\n"
16931 " which supports separate text and graphics windows, this command causes\n"
16932 " control to be switched to the graphics window. If already in graphics\n"
16933 " mode, this command is ignored. It is also ignored on devices which\n"
16934 " only support a single window or use a different method for shifting\n"
16935 " focus. See also pltext.\n"
16936 "\n"
16937 " Redacted form: plgra()\n"
16938 "\n"
16939 " This function is used in example 1.\n"
16940 "\n"
16941 "\n"
16942 "\n"
16943 "SYNOPSIS:\n"
16944 "\n"
16945 "plgra()\n"
16946 "\n"
16947 ""},
16948 { "plgriddata", _wrap_plgriddata, METH_VARARGS, "\n"
16949 "Grid data from irregularly sampled data\n"
16950 "\n"
16951 "DESCRIPTION:\n"
16952 "\n"
16953 " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
16954 " require data organized as a grid, i.e., with x sample point values\n"
16955 " independent of y coordinate and vice versa. This function takes\n"
16956 " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
16957 " vectors; reads the desired grid location from the input vectors\n"
16958 " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
16959 " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
16960 " interpolate the data to the grid is specified with the argument type\n"
16961 " which can have one parameter specified in argument data.\n"
16962 "\n"
16963 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
16964 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
16965 "\n"
16966 "\n"
16967 " This function is used in example 21.\n"
16968 "\n"
16969 "\n"
16970 "\n"
16971 "SYNOPSIS:\n"
16972 "\n"
16973 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
16974 "\n"
16975 "ARGUMENTS:\n"
16976 "\n"
16977 " x (PLFLT_VECTOR, input) : The input x vector.\n"
16978 "\n"
16979 " y (PLFLT_VECTOR, input) : The input y vector.\n"
16980 "\n"
16981 " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
16982 " y[i], z[i] represents one data sample coordinate.\n"
16983 "\n"
16984 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
16985 " vectors.\n"
16986 "\n"
16987 " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
16988 " in the x direction. Usually xg has nptsx equally spaced values\n"
16989 " from the minimum to the maximum values of the x input vector.\n"
16990 "\n"
16991 " nptsx (PLINT, input) : The number of points in the xg vector.\n"
16992 "\n"
16993 " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
16994 " in the y direction. Similar to the xg parameter.\n"
16995 "\n"
16996 " nptsy (PLINT, input) : The number of points in the yg vector.\n"
16997 "\n"
16998 " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
16999 " where data lies in the grid specified by xg and yg. Therefore the\n"
17000 " zg matrix must be dimensioned\n"
17001 " nptsx by\n"
17002 " nptsy.\n"
17003 "\n"
17004 " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17005 " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17006 " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17007 " GRID_NNI: Natural Neighbors Interpolation\n"
17008 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17009 " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17010 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17011 " Weighted\n"
17012 " For details of the algorithms read the source file plgridd.c.\n"
17013 "\n"
17014 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17015 " which can be specified through this argument. Currently, for\n"
17016 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17017 " use, the lower the value, the noisier (more local) the\n"
17018 " approximation is.\n"
17019 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17020 " range [1. .. 2.]. High values enable the usage of very thin\n"
17021 " triangles for interpolation, possibly resulting in error in\n"
17022 " the approximation.\n"
17023 " GRID_NNI, only weights greater than data will be accepted. If\n"
17024 " 0, all weights will be accepted.\n"
17025 "\n"
17026 ""},
17027 { "plgspa", _wrap_plgspa, METH_NOARGS, "\n"
17028 "Get current subpage parameters\n"
17029 "\n"
17030 "DESCRIPTION:\n"
17031 "\n"
17032 " Gets the size of the current subpage in millimeters measured from the\n"
17033 " bottom left hand corner of the output device page or screen. Can be\n"
17034 " used in conjunction with plsvpa for setting the size of a viewport in\n"
17035 " absolute coordinates (millimeters).\n"
17036 "\n"
17037 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17038 "\n"
17039 " This function is used in example 23.\n"
17040 "\n"
17041 "\n"
17042 "\n"
17043 "SYNOPSIS:\n"
17044 "\n"
17045 "plgspa(xmin, xmax, ymin, ymax)\n"
17046 "\n"
17047 "ARGUMENTS:\n"
17048 "\n"
17049 " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17050 " the left hand edge of the subpage in millimeters.\n"
17051 "\n"
17052 " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17053 " the right hand edge of the subpage in millimeters.\n"
17054 "\n"
17055 " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17056 " the bottom edge of the subpage in millimeters.\n"
17057 "\n"
17058 " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17059 " the top edge of the subpage in millimeters.\n"
17060 "\n"
17061 ""},
17062 { "plgstrm", _wrap_plgstrm, METH_NOARGS, "\n"
17063 "Get current stream number\n"
17064 "\n"
17065 "DESCRIPTION:\n"
17066 "\n"
17067 " Gets the number of the current output stream. See also plsstrm.\n"
17068 "\n"
17069 " Redacted form: plgstrm(p_strm)\n"
17070 "\n"
17071 " This function is used in example 1,20.\n"
17072 "\n"
17073 "\n"
17074 "\n"
17075 "SYNOPSIS:\n"
17076 "\n"
17077 "plgstrm(p_strm)\n"
17078 "\n"
17079 "ARGUMENTS:\n"
17080 "\n"
17081 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17082 " stream value.\n"
17083 "\n"
17084 ""},
17085 { "plgver", _wrap_plgver, METH_NOARGS, "\n"
17086 "Get the current library version number\n"
17087 "\n"
17088 "DESCRIPTION:\n"
17089 "\n"
17090 " Get the current library version number. Note: you must have allocated\n"
17091 " space for this (80 characters is safe).\n"
17092 "\n"
17093 " Redacted form: plgver(p_ver)\n"
17094 "\n"
17095 " This function is used in example 1.\n"
17096 "\n"
17097 "\n"
17098 "\n"
17099 "SYNOPSIS:\n"
17100 "\n"
17101 "plgver(p_ver)\n"
17102 "\n"
17103 "ARGUMENTS:\n"
17104 "\n"
17105 " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17106 " (with preallocated length of 80 characters or more) containing the\n"
17107 " PLplot version number.\n"
17108 "\n"
17109 ""},
17110 { "plgvpd", _wrap_plgvpd, METH_NOARGS, "\n"
17111 "Get viewport limits in normalized device coordinates\n"
17112 "\n"
17113 "DESCRIPTION:\n"
17114 "\n"
17115 " Get viewport limits in normalized device coordinates.\n"
17116 "\n"
17117 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17118 "\n"
17119 "\n"
17120 " This function is used in example 31.\n"
17121 "\n"
17122 "\n"
17123 "\n"
17124 "SYNOPSIS:\n"
17125 "\n"
17126 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17127 "\n"
17128 "ARGUMENTS:\n"
17129 "\n"
17130 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17131 " viewport limit of the normalized device coordinate in x.\n"
17132 "\n"
17133 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17134 " viewport limit of the normalized device coordinate in x.\n"
17135 "\n"
17136 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17137 " viewport limit of the normalized device coordinate in y.\n"
17138 "\n"
17139 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17140 " viewport limit of the normalized device coordinate in y.\n"
17141 "\n"
17142 ""},
17143 { "plgvpw", _wrap_plgvpw, METH_NOARGS, "\n"
17144 "Get viewport limits in world coordinates\n"
17145 "\n"
17146 "DESCRIPTION:\n"
17147 "\n"
17148 " Get viewport limits in world coordinates.\n"
17149 "\n"
17150 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17151 "\n"
17152 "\n"
17153 " This function is used in example 31.\n"
17154 "\n"
17155 "\n"
17156 "\n"
17157 "SYNOPSIS:\n"
17158 "\n"
17159 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17160 "\n"
17161 "ARGUMENTS:\n"
17162 "\n"
17163 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17164 " viewport limit of the world coordinate in x.\n"
17165 "\n"
17166 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17167 " viewport limit of the world coordinate in x.\n"
17168 "\n"
17169 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17170 " viewport limit of the world coordinate in y.\n"
17171 "\n"
17172 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17173 " viewport limit of the world coordinate in y.\n"
17174 "\n"
17175 ""},
17176 { "plgxax", _wrap_plgxax, METH_NOARGS, "\n"
17177 "Get x axis parameters\n"
17178 "\n"
17179 "DESCRIPTION:\n"
17180 "\n"
17181 " Returns current values of the p_digmax and p_digits flags for the x\n"
17182 " axis. p_digits is updated after the plot is drawn, so this routine\n"
17183 " should only be called after the call to plbox (or plbox3) is complete.\n"
17184 " See the PLplot documentation for more information.\n"
17185 "\n"
17186 " Redacted form: plgxax(p_digmax, p_digits)\n"
17187 "\n"
17188 " This function is used in example 31.\n"
17189 "\n"
17190 "\n"
17191 "\n"
17192 "SYNOPSIS:\n"
17193 "\n"
17194 "plgxax(p_digmax, p_digits)\n"
17195 "\n"
17196 "ARGUMENTS:\n"
17197 "\n"
17198 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17199 " number of digits for the x axis. If nonzero, the printed label\n"
17200 " has been switched to a floating-point representation when the\n"
17201 " number of digits exceeds this value.\n"
17202 "\n"
17203 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17204 " number of digits for the numeric labels (x axis) from the last\n"
17205 " plot.\n"
17206 "\n"
17207 ""},
17208 { "plgyax", _wrap_plgyax, METH_NOARGS, "\n"
17209 "Get y axis parameters\n"
17210 "\n"
17211 "DESCRIPTION:\n"
17212 "\n"
17213 " Identical to plgxax, except that arguments are flags for y axis. See\n"
17214 " the description of plgxax for more detail.\n"
17215 "\n"
17216 " Redacted form: plgyax(p_digmax, p_digits)\n"
17217 "\n"
17218 " This function is used in example 31.\n"
17219 "\n"
17220 "\n"
17221 "\n"
17222 "SYNOPSIS:\n"
17223 "\n"
17224 "plgyax(p_digmax, p_digits)\n"
17225 "\n"
17226 "ARGUMENTS:\n"
17227 "\n"
17228 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17229 " number of digits for the y axis. If nonzero, the printed label\n"
17230 " has been switched to a floating-point representation when the\n"
17231 " number of digits exceeds this value.\n"
17232 "\n"
17233 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17234 " number of digits for the numeric labels (y axis) from the last\n"
17235 " plot.\n"
17236 "\n"
17237 ""},
17238 { "plgzax", _wrap_plgzax, METH_NOARGS, "\n"
17239 "Get z axis parameters\n"
17240 "\n"
17241 "DESCRIPTION:\n"
17242 "\n"
17243 " Identical to plgxax, except that arguments are flags for z axis. See\n"
17244 " the description of plgxax for more detail.\n"
17245 "\n"
17246 " Redacted form: plgzax(p_digmax, p_digits)\n"
17247 "\n"
17248 " This function is used in example 31.\n"
17249 "\n"
17250 "\n"
17251 "\n"
17252 "SYNOPSIS:\n"
17253 "\n"
17254 "plgzax(p_digmax, p_digits)\n"
17255 "\n"
17256 "ARGUMENTS:\n"
17257 "\n"
17258 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17259 " number of digits for the z axis. If nonzero, the printed label\n"
17260 " has been switched to a floating-point representation when the\n"
17261 " number of digits exceeds this value.\n"
17262 "\n"
17263 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17264 " number of digits for the numeric labels (z axis) from the last\n"
17265 " plot.\n"
17266 "\n"
17267 ""},
17268 { "plhist", _wrap_plhist, METH_VARARGS, "\n"
17269 "Plot a histogram from unbinned data\n"
17270 "\n"
17271 "DESCRIPTION:\n"
17272 "\n"
17273 " Plots a histogram from n data points stored in the data vector. This\n"
17274 " routine bins the data into nbin bins equally spaced between datmin and\n"
17275 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17276 " opt allows, among other things, the histogram either to be plotted in\n"
17277 " an existing window or causes plhist to call plenv with suitable limits\n"
17278 " before plotting the histogram.\n"
17279 "\n"
17280 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17281 "\n"
17282 " This function is used in example 5.\n"
17283 "\n"
17284 "\n"
17285 "\n"
17286 "SYNOPSIS:\n"
17287 "\n"
17288 "plhist(n, data, datmin, datmax, nbin, opt)\n"
17289 "\n"
17290 "ARGUMENTS:\n"
17291 "\n"
17292 " n (PLINT, input) : Number of data points.\n"
17293 "\n"
17294 " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17295 " n data points.\n"
17296 "\n"
17297 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17298 "\n"
17299 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17300 "\n"
17301 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17302 " divide the interval xmin to xmax.\n"
17303 "\n"
17304 " opt (PLINT, input) : Is a combination of several flags:\n"
17305 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17306 " the histogram data, the outer bins are expanded to fill up the\n"
17307 " entire x-axis, data outside the given extremes are assigned to the\n"
17308 " outer bins and bins of zero height are simply drawn.\n"
17309 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17310 " to fit the histogram data, without this flag, plenv is called\n"
17311 " to set the world coordinates.\n"
17312 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17313 " extremes are not taken into account. This option should\n"
17314 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17315 " properly present the data.\n"
17316 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17317 " size as the ones inside.\n"
17318 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17319 " (there is a gap for such bins).\n"
17320 "\n"
17321 ""},
17322 { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, "\n"
17323 "Convert HLS color to RGB\n"
17324 "\n"
17325 "DESCRIPTION:\n"
17326 "\n"
17327 " Convert HLS color coordinates to RGB.\n"
17328 "\n"
17329 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17330 "\n"
17331 "\n"
17332 " This function is used in example 2.\n"
17333 "\n"
17334 "\n"
17335 "\n"
17336 "SYNOPSIS:\n"
17337 "\n"
17338 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17339 "\n"
17340 "ARGUMENTS:\n"
17341 "\n"
17342 " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17343 " cylinder.\n"
17344 "\n"
17345 " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17346 " the axis of the color cylinder.\n"
17347 "\n"
17348 " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17349 " the radius of the color cylinder.\n"
17350 "\n"
17351 " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17352 " (0.0-1.0) of the color.\n"
17353 "\n"
17354 " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17355 " intensity (0.0-1.0) of the color.\n"
17356 "\n"
17357 " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17358 " intensity (0.0-1.0) of the color.\n"
17359 "\n"
17360 ""},
17361 { "plinit", _wrap_plinit, METH_NOARGS, "\n"
17362 "Initialize PLplot\n"
17363 "\n"
17364 "DESCRIPTION:\n"
17365 "\n"
17366 " Initializing the plotting package. The program prompts for the device\n"
17367 " keyword or number of the desired output device. Hitting a RETURN in\n"
17368 " response to the prompt is the same as selecting the first device.\n"
17369 " plinit will issue no prompt if either the device was specified\n"
17370 " previously (via command line flag, the plsetopt function, or the\n"
17371 " plsdev function), or if only one device is enabled when PLplot is\n"
17372 " installed. If subpages have been specified, the output device is\n"
17373 " divided into nx by ny subpages, each of which may be used\n"
17374 " independently. If plinit is called again during a program, the\n"
17375 " previously opened file will be closed. The subroutine pladv is used\n"
17376 " to advance from one subpage to the next.\n"
17377 "\n"
17378 " Redacted form: plinit()\n"
17379 "\n"
17380 " This function is used in all of the examples.\n"
17381 "\n"
17382 "\n"
17383 "\n"
17384 "SYNOPSIS:\n"
17385 "\n"
17386 "plinit()\n"
17387 "\n"
17388 ""},
17389 { "pljoin", _wrap_pljoin, METH_VARARGS, "\n"
17390 "Draw a line between two points\n"
17391 "\n"
17392 "DESCRIPTION:\n"
17393 "\n"
17394 " Joins the point (\n"
17395 " x1,\n"
17396 " y1) to (\n"
17397 " x2,\n"
17398 " y2).\n"
17399 "\n"
17400 " Redacted form: pljoin(x1,y1,x2,y2)\n"
17401 "\n"
17402 " This function is used in examples 3 and 14.\n"
17403 "\n"
17404 "\n"
17405 "\n"
17406 "SYNOPSIS:\n"
17407 "\n"
17408 "pljoin(x1, y1, x2, y2)\n"
17409 "\n"
17410 "ARGUMENTS:\n"
17411 "\n"
17412 " x1 (PLFLT, input) : x coordinate of first point.\n"
17413 "\n"
17414 " y1 (PLFLT, input) : y coordinate of first point.\n"
17415 "\n"
17416 " x2 (PLFLT, input) : x coordinate of second point.\n"
17417 "\n"
17418 " y2 (PLFLT, input) : y coordinate of second point.\n"
17419 "\n"
17420 ""},
17421 { "pllab", _wrap_pllab, METH_VARARGS, "\n"
17422 "Simple routine to write labels\n"
17423 "\n"
17424 "DESCRIPTION:\n"
17425 "\n"
17426 " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17427 "\n"
17428 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17429 "\n"
17430 " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17431 "\n"
17432 "\n"
17433 "\n"
17434 "SYNOPSIS:\n"
17435 "\n"
17436 "pllab(xlabel, ylabel, tlabel)\n"
17437 "\n"
17438 "ARGUMENTS:\n"
17439 "\n"
17440 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17441 " the label for the x axis.\n"
17442 "\n"
17443 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17444 " the label for the y axis.\n"
17445 "\n"
17446 " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17447 " the title of the plot.\n"
17448 "\n"
17449 ""},
17450 { "pllegend", _wrap_pllegend, METH_VARARGS, "\n"
17451 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17452 "\n"
17453 "DESCRIPTION:\n"
17454 "\n"
17455 " Routine for creating a discrete plot legend with a plotted filled box,\n"
17456 " line, and/or line of symbols for each annotated legend entry. (See\n"
17457 " plcolorbar for similar functionality for creating continuous color\n"
17458 " bars.) The arguments of pllegend provide control over the location\n"
17459 " and size of the legend as well as the location and characteristics of\n"
17460 " the elements (most of which are optional) within that legend. The\n"
17461 " resulting legend is clipped at the boundaries of the current subpage.\n"
17462 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17463 " defined in the documentation of the position parameter.)\n"
17464 "\n"
17465 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17466 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17467 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17468 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17469 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17470 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17471 "\n"
17472 " This function is used in examples 4, 26, and 33.\n"
17473 "\n"
17474 "\n"
17475 "\n"
17476 "SYNOPSIS:\n"
17477 "\n"
17478 "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"
17479 "\n"
17480 "ARGUMENTS:\n"
17481 "\n"
17482 " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17483 " legend width in adopted coordinates. This quantity is calculated\n"
17484 " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17485 " the routine depending on nlegend and nrow), and the length\n"
17486 " (calculated internally) of the longest text string.\n"
17487 "\n"
17488 " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17489 " legend height in adopted coordinates. This quantity is calculated\n"
17490 " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17491 " the routine depending on nlegend and nrow).\n"
17492 "\n"
17493 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17494 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17495 " on the left of the legend and the plotted area on the right.\n"
17496 " Otherwise, put the text area on the right of the legend and the\n"
17497 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17498 " plot a (semitransparent) background for the legend. If the\n"
17499 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17500 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17501 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17502 " plot the resulting array of legend entries in row-major order.\n"
17503 " Otherwise, plot the legend entries in column-major order.\n"
17504 "\n"
17505 " position (PLINT, input) : position contains bits which control the\n"
17506 " overall position of the legend and the definition of the adopted\n"
17507 " coordinates used for positions just like what is done for the\n"
17508 " position argument for plcolorbar. However, note that the defaults\n"
17509 " for the position bits (see below) are different than the\n"
17510 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17511 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17512 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17513 " the 16 possible standard positions (the 4 corners and centers of\n"
17514 " the 4 sides for both the inside and outside cases) of the legend\n"
17515 " relative to the adopted coordinate system. The corner positions\n"
17516 " are specified by the appropriate combination of two of the\n"
17517 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17518 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17519 " value of one of those bits. The adopted coordinates are\n"
17520 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17521 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17522 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17523 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17524 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17525 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17526 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17527 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17528 "\n"
17529 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17530 " coordinates from the specified standard position of the legend.\n"
17531 " For positive x, the direction of motion away from the standard\n"
17532 " position is inward/outward from the standard corner positions or\n"
17533 " standard left or right positions if the\n"
17534 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17535 " For the standard top or bottom positions, the direction of motion\n"
17536 " is toward positive X.\n"
17537 "\n"
17538 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17539 " coordinates from the specified standard position of the legend.\n"
17540 " For positive y, the direction of motion away from the standard\n"
17541 " position is inward/outward from the standard corner positions or\n"
17542 " standard top or bottom positions if the\n"
17543 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17544 " the standard left or right positions, the direction of motion is\n"
17545 " toward positive Y.\n"
17546 "\n"
17547 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17548 " of the plot area (where the colored boxes, lines, and/or lines of\n"
17549 " symbols are drawn) of the legend.\n"
17550 "\n"
17551 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17552 " legend (PL_LEGEND_BACKGROUND).\n"
17553 "\n"
17554 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17555 " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17556 "\n"
17557 " bb_style (PLINT, input) : The pllsty style number for the\n"
17558 " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
17559 "\n"
17560 " nrow (PLINT, input) : The number of rows in the matrix used to\n"
17561 " render the\n"
17562 " nlegend legend entries. For internal transformations of\n"
17563 " nrow, see further remarks under\n"
17564 " nlegend.\n"
17565 "\n"
17566 " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
17567 " to render the\n"
17568 " nlegend legend entries. For internal transformations of\n"
17569 " ncolumn, see further remarks under\n"
17570 " nlegend.\n"
17571 "\n"
17572 " nlegend (PLINT, input) : Number of legend entries. The above\n"
17573 " nrow and\n"
17574 " ncolumn values are transformed internally to be consistent with\n"
17575 " nlegend. If either\n"
17576 " nrow or\n"
17577 " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
17578 " of\n"
17579 " nrow and\n"
17580 " ncolumn is less than\n"
17581 " nlegend, the smaller of the two (or\n"
17582 " nrow, if\n"
17583 " nrow ==\n"
17584 " ncolumn) is increased so the product is >=\n"
17585 " nlegend. Thus, for example, the common\n"
17586 " nrow = 0,\n"
17587 " ncolumn = 0 case is transformed internally to\n"
17588 " nrow =\n"
17589 " nlegend,\n"
17590 " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
17591 " column.\n"
17592 "\n"
17593 " opt_array (PLINT_VECTOR, input) : A vector of\n"
17594 " nlegend values of options to control each individual plotted area\n"
17595 " corresponding to a legend entry. If the\n"
17596 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
17597 " area. If the\n"
17598 " PL_LEGEND_COLOR_BOX,\n"
17599 " PL_LEGEND_LINE, and/or\n"
17600 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
17601 " entry is plotted with a colored box; a line; and/or a line of\n"
17602 " symbols.\n"
17603 "\n"
17604 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
17605 " area in units of character width.\n"
17606 "\n"
17607 " text_scale (PLFLT, input) : Character height scale for text\n"
17608 " annotations.\n"
17609 "\n"
17610 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
17611 " character height from one legend entry to the next.\n"
17612 "\n"
17613 " text_justification (PLFLT, input) : Justification parameter used\n"
17614 " for text justification. The most common values of\n"
17615 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
17616 " is left justified, centred, or right justified within the text\n"
17617 " area, but other values are allowed as well.\n"
17618 "\n"
17619 " text_colors (PLINT_VECTOR, input) : A vector containing\n"
17620 " nlegend cmap0 text colors.\n"
17621 "\n"
17622 " text (PLCHAR_MATRIX, input) : A vector of\n"
17623 " nlegend UTF-8 character strings containing the legend annotations.\n"
17624 "\n"
17625 " box_colors (PLINT_VECTOR, input) : A vector containing\n"
17626 " nlegend cmap0 colors for the discrete colored boxes (\n"
17627 " PL_LEGEND_COLOR_BOX).\n"
17628 "\n"
17629 " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
17630 " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
17631 " PL_LEGEND_COLOR_BOX).\n"
17632 "\n"
17633 " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
17634 " nlegend scales (units of fraction of character height) for the height\n"
17635 " of the discrete colored boxes (\n"
17636 " PL_LEGEND_COLOR_BOX).\n"
17637 "\n"
17638 " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17639 " nlegend line widths for the patterns specified by box_patterns (\n"
17640 " PL_LEGEND_COLOR_BOX).\n"
17641 "\n"
17642 " line_colors (PLINT_VECTOR, input) : A vector containing\n"
17643 " nlegend cmap0 line colors (\n"
17644 " PL_LEGEND_LINE).\n"
17645 "\n"
17646 " line_styles (PLINT_VECTOR, input) : A vector containing\n"
17647 " nlegend line styles (plsty indices) (\n"
17648 " PL_LEGEND_LINE).\n"
17649 "\n"
17650 " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
17651 " nlegend line widths (\n"
17652 " PL_LEGEND_LINE).\n"
17653 "\n"
17654 " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
17655 " nlegend cmap0 symbol colors (\n"
17656 " PL_LEGEND_SYMBOL).\n"
17657 "\n"
17658 " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
17659 " nlegend scale values for the symbol height (\n"
17660 " PL_LEGEND_SYMBOL).\n"
17661 "\n"
17662 " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
17663 " nlegend numbers of symbols to be drawn across the width of the plotted\n"
17664 " area (\n"
17665 " PL_LEGEND_SYMBOL).\n"
17666 "\n"
17667 " symbols (PLCHAR_MATRIX, input) : A vector of\n"
17668 " nlegend UTF-8 character strings containing the legend symbols. (\n"
17669 " PL_LEGEND_SYMBOL).\n"
17670 "\n"
17671 ""},
17672 { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, "\n"
17673 "Plot color bar for image, shade or gradient plots\n"
17674 "\n"
17675 "DESCRIPTION:\n"
17676 "\n"
17677 " Routine for creating a continuous color bar for image, shade, or\n"
17678 " gradient plots. (See pllegend for similar functionality for creating\n"
17679 " legends with discrete elements). The arguments of plcolorbar provide\n"
17680 " control over the location and size of the color bar as well as the\n"
17681 " location and characteristics of the elements (most of which are\n"
17682 " optional) within that color bar. The resulting color bar is clipped\n"
17683 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
17684 " system used for some of the parameters is defined in the documentation\n"
17685 " of the position parameter.)\n"
17686 "\n"
17687 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
17688 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
17689 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
17690 " labels, axis_opts, ticks, sub_ticks, values)\n"
17691 "\n"
17692 " This function is used in examples 16 and 33.\n"
17693 "\n"
17694 "\n"
17695 "\n"
17696 "SYNOPSIS:\n"
17697 "\n"
17698 "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"
17699 "\n"
17700 "ARGUMENTS:\n"
17701 "\n"
17702 " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17703 " labelled and decorated color bar width in adopted coordinates.\n"
17704 "\n"
17705 " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17706 " labelled and decorated color bar height in adopted coordinates.\n"
17707 "\n"
17708 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17709 " color bar. The orientation (direction of the maximum value) of\n"
17710 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
17711 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
17712 " specified, the default orientation is toward the top if the\n"
17713 " colorbar is placed on the left or right of the viewport or toward\n"
17714 " the right if the colorbar is placed on the top or bottom of the\n"
17715 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
17716 " (semitransparent) background for the color bar. If the\n"
17717 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17718 " color bar. The type of color bar must be specified with one of\n"
17719 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
17720 " more than one of those bits is set only the first one in the above\n"
17721 " list is honored. The position of the (optional) label/title can be\n"
17722 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
17723 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
17724 " will be drawn. If more than one of this list of bits is specified,\n"
17725 " only the first one on the list is honored. End-caps for the color\n"
17726 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
17727 " If a particular color bar cap option is not specified then no cap\n"
17728 " will be drawn for that end. As a special case for\n"
17729 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
17730 " specified. If this option is provided then any tick marks and tick\n"
17731 " labels will be placed at the breaks between shaded segments. TODO:\n"
17732 " This should be expanded to support custom placement of tick marks\n"
17733 " and tick labels at custom value locations for any color bar type.\n"
17734 "\n"
17735 " position (PLINT, input) : position contains bits which control the\n"
17736 " overall position of the color bar and the definition of the\n"
17737 " adopted coordinates used for positions just like what is done for\n"
17738 " the position argument for pllegend. However, note that the\n"
17739 " defaults for the position bits (see below) are different than the\n"
17740 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
17741 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17742 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17743 " the 16 possible standard positions (the 4 corners and centers of\n"
17744 " the 4 sides for both the inside and outside cases) of the color\n"
17745 " bar relative to the adopted coordinate system. The corner\n"
17746 " positions are specified by the appropriate combination of two of\n"
17747 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17748 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17749 " value of one of those bits. The adopted coordinates are\n"
17750 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17751 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17752 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17753 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17754 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
17755 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
17756 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
17757 " PL_POSITION_VIEWPORT.\n"
17758 "\n"
17759 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
17760 " coordinates from the specified standard position of the color bar.\n"
17761 " For positive x, the direction of motion away from the standard\n"
17762 " position is inward/outward from the standard corner positions or\n"
17763 " standard left or right positions if the\n"
17764 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17765 " For the standard top or bottom positions, the direction of motion\n"
17766 " is toward positive X.\n"
17767 "\n"
17768 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
17769 " coordinates from the specified standard position of the color bar.\n"
17770 " For positive y, the direction of motion away from the standard\n"
17771 " position is inward/outward from the standard corner positions or\n"
17772 " standard top or bottom positions if the\n"
17773 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17774 " For the standard left or right positions, the direction of motion\n"
17775 " is toward positive Y.\n"
17776 "\n"
17777 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
17778 " the X direction in adopted coordinates.\n"
17779 "\n"
17780 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
17781 " the Y direction in adopted coordinates.\n"
17782 "\n"
17783 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17784 " color bar (PL_COLORBAR_BACKGROUND).\n"
17785 "\n"
17786 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17787 " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
17788 "\n"
17789 " bb_style (PLINT, input) : The pllsty style number for the\n"
17790 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
17791 "\n"
17792 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
17793 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
17794 "\n"
17795 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
17796 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
17797 "\n"
17798 " cont_color (PLINT, input) : The cmap0 contour color for\n"
17799 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
17800 " it will be interpreted according to the design of plshades.\n"
17801 "\n"
17802 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
17803 " plots. This is passed directly to plshades, so it will be\n"
17804 " interpreted according to the design of plshades.\n"
17805 "\n"
17806 " n_labels (PLINT, input) : Number of labels to place around the\n"
17807 " color bar.\n"
17808 "\n"
17809 " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
17810 " n_labels labels.\n"
17811 "\n"
17812 " labels (PLCHAR_MATRIX, input) : A vector of\n"
17813 " n_labels UTF-8 character strings containing the labels for the color\n"
17814 " bar. Ignored if no label position is specified with one of the\n"
17815 " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
17816 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
17817 " corresponding label_opts field.\n"
17818 "\n"
17819 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
17820 " value must be greater than 0. It is typically 1 (numerical axis\n"
17821 " labels are provided for one of the long edges of the color bar),\n"
17822 " but it can be larger if multiple numerical axis labels for the\n"
17823 " long edges of the color bar are desired.\n"
17824 "\n"
17825 " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
17826 " n_axes ascii character strings containing options (interpreted as for\n"
17827 " plbox) for the color bar's axis definitions.\n"
17828 "\n"
17829 " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
17830 " spacing of the major tick marks (interpreted as for plbox) for the\n"
17831 " color bar's axis definitions.\n"
17832 "\n"
17833 " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
17834 " number of subticks (interpreted as for plbox) for the color bar's\n"
17835 " axis definitions.\n"
17836 "\n"
17837 " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
17838 " elements in each of the n_axes rows of the values matrix.\n"
17839 "\n"
17840 " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
17841 " values for the data range represented by the color bar. For a row\n"
17842 " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
17843 " elements in the row is specified by n_values[i_axis]. For\n"
17844 " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
17845 " is 2, and the corresponding row elements of the values matrix are\n"
17846 " the minimum and maximum value represented by the colorbar. For\n"
17847 " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
17848 " of the values matrix is interpreted the same as the nlevel and\n"
17849 " clevel arguments of plshades.\n"
17850 "\n"
17851 ""},
17852 { "pllightsource", _wrap_pllightsource, METH_VARARGS, "\n"
17853 "Sets the 3D position of the light source\n"
17854 "\n"
17855 "DESCRIPTION:\n"
17856 "\n"
17857 " Sets the 3D position of the light source for use with plsurf3d and\n"
17858 " plsurf3dl\n"
17859 "\n"
17860 " Redacted form: pllightsource(x, y, z)\n"
17861 "\n"
17862 " This function is used in example 8.\n"
17863 "\n"
17864 "\n"
17865 "\n"
17866 "SYNOPSIS:\n"
17867 "\n"
17868 "pllightsource(x, y, z)\n"
17869 "\n"
17870 "ARGUMENTS:\n"
17871 "\n"
17872 " x (PLFLT, input) : X-coordinate of the light source.\n"
17873 "\n"
17874 " y (PLFLT, input) : Y-coordinate of the light source.\n"
17875 "\n"
17876 " z (PLFLT, input) : Z-coordinate of the light source.\n"
17877 "\n"
17878 ""},
17879 { "plline", _wrap_plline, METH_VARARGS, "\n"
17880 "Draw a line\n"
17881 "\n"
17882 "DESCRIPTION:\n"
17883 "\n"
17884 " Draws line defined by n points in x and y.\n"
17885 "\n"
17886 " Redacted form: plline(x, y)\n"
17887 "\n"
17888 " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
17889 " 25-27, and 29.\n"
17890 "\n"
17891 "\n"
17892 "\n"
17893 "SYNOPSIS:\n"
17894 "\n"
17895 "plline(n, x, y)\n"
17896 "\n"
17897 "ARGUMENTS:\n"
17898 "\n"
17899 " n (PLINT, input) : Number of points defining line.\n"
17900 "\n"
17901 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
17902 " points.\n"
17903 "\n"
17904 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
17905 " points.\n"
17906 "\n"
17907 ""},
17908 { "plline3", _wrap_plline3, METH_VARARGS, "\n"
17909 "Draw a line in 3 space\n"
17910 "\n"
17911 "DESCRIPTION:\n"
17912 "\n"
17913 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
17914 " first set up the viewport, the 2d viewing window (in world\n"
17915 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
17916 " more info.\n"
17917 "\n"
17918 " Redacted form: plline3(x, y, z)\n"
17919 "\n"
17920 " This function is used in example 18.\n"
17921 "\n"
17922 "\n"
17923 "\n"
17924 "SYNOPSIS:\n"
17925 "\n"
17926 "plline3(n, x, y, z)\n"
17927 "\n"
17928 "ARGUMENTS:\n"
17929 "\n"
17930 " n (PLINT, input) : Number of points defining line.\n"
17931 "\n"
17932 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
17933 " points.\n"
17934 "\n"
17935 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
17936 " points.\n"
17937 "\n"
17938 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
17939 " points.\n"
17940 "\n"
17941 ""},
17942 { "pllsty", _wrap_pllsty, METH_O, "\n"
17943 "Select line style\n"
17944 "\n"
17945 "DESCRIPTION:\n"
17946 "\n"
17947 " This sets the line style according to one of eight predefined patterns\n"
17948 " (also see plstyl).\n"
17949 "\n"
17950 " Redacted form: pllsty(lin)\n"
17951 "\n"
17952 " This function is used in examples 9, 12, 22, and 25.\n"
17953 "\n"
17954 "\n"
17955 "\n"
17956 "SYNOPSIS:\n"
17957 "\n"
17958 "pllsty(lin)\n"
17959 "\n"
17960 "ARGUMENTS:\n"
17961 "\n"
17962 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
17963 " a continuous line, line style 2 is a line with short dashes and\n"
17964 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
17965 " 4 has long dashes and short gaps and so on.\n"
17966 "\n"
17967 ""},
17968 { "plmesh", _wrap_plmesh, METH_VARARGS, "\n"
17969 "Plot surface mesh\n"
17970 "\n"
17971 "DESCRIPTION:\n"
17972 "\n"
17973 " Plots a surface mesh within the environment set up by plw3d. The\n"
17974 " surface is defined by the matrix z[\n"
17975 " nx][\n"
17976 " ny] , the point z[i][j] being the value of the function at (\n"
17977 " x[i],\n"
17978 " y[j]). Note that the points in vectors x and y do not need to be\n"
17979 " equally spaced, but must be stored in ascending order. The parameter\n"
17980 " opt controls the way in which the surface is displayed. For further\n"
17981 " details see the PLplot documentation.\n"
17982 "\n"
17983 " Redacted form: plmesh(x, y, z, opt)\n"
17984 "\n"
17985 " This function is used in example 11.\n"
17986 "\n"
17987 "\n"
17988 "\n"
17989 "SYNOPSIS:\n"
17990 "\n"
17991 "plmesh(x, y, z, nx, ny, opt)\n"
17992 "\n"
17993 "ARGUMENTS:\n"
17994 "\n"
17995 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
17996 " which the function is evaluated.\n"
17997 "\n"
17998 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
17999 " which the function is evaluated.\n"
18000 "\n"
18001 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18002 " plot. Should have dimensions of\n"
18003 " nx by\n"
18004 " ny.\n"
18005 "\n"
18006 " nx (PLINT, input) : Number of x values at which function has been\n"
18007 " evaluated.\n"
18008 "\n"
18009 " ny (PLINT, input) : Number of y values at which function has been\n"
18010 " evaluated.\n"
18011 "\n"
18012 " opt (PLINT, input) : Determines the way in which the surface is\n"
18013 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18014 " function of x for each value of y[j] .\n"
18015 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18016 " for each value of x[i] .\n"
18017 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18018 " at which function is defined.\n"
18019 "\n"
18020 ""},
18021 { "plmeshc", _wrap_plmeshc, METH_VARARGS, "\n"
18022 "Magnitude colored plot surface mesh with contour\n"
18023 "\n"
18024 "DESCRIPTION:\n"
18025 "\n"
18026 " A more powerful form of plmesh: the surface mesh can be colored\n"
18027 " accordingly to the current z value being plotted, a contour plot can\n"
18028 " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18029 " plotted function border and the base XY plane.\n"
18030 "\n"
18031 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18032 "\n"
18033 " This function is used in example 11.\n"
18034 "\n"
18035 "\n"
18036 "\n"
18037 "SYNOPSIS:\n"
18038 "\n"
18039 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18040 "\n"
18041 "ARGUMENTS:\n"
18042 "\n"
18043 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18044 " which the function is evaluated.\n"
18045 "\n"
18046 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18047 " which the function is evaluated.\n"
18048 "\n"
18049 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18050 " plot. Should have dimensions of\n"
18051 " nx by\n"
18052 " ny.\n"
18053 "\n"
18054 " nx (PLINT, input) : Number of x values at which function is\n"
18055 " evaluated.\n"
18056 "\n"
18057 " ny (PLINT, input) : Number of y values at which function is\n"
18058 " evaluated.\n"
18059 "\n"
18060 " opt (PLINT, input) : Determines the way in which the surface is\n"
18061 " represented. To specify more than one option just add the options,\n"
18062 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18063 " showing z as a function of x for each value of y[j] .\n"
18064 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18065 " for each value of x[i] .\n"
18066 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18067 " at which function is defined.\n"
18068 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18069 " the z value being plotted. The color is used from the current\n"
18070 " cmap1.\n"
18071 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18072 " using parameters\n"
18073 " nlevel and\n"
18074 " clevel.\n"
18075 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18076 " the borders of the plotted function.\n"
18077 "\n"
18078 "\n"
18079 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18080 " levels.\n"
18081 "\n"
18082 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18083 "\n"
18084 ""},
18085 { "plmkstrm", _wrap_plmkstrm, METH_NOARGS, "\n"
18086 "Creates a new stream and makes it the default\n"
18087 "\n"
18088 "DESCRIPTION:\n"
18089 "\n"
18090 " Creates a new stream and makes it the default. Differs from using\n"
18091 " plsstrm, in that a free stream number is found, and returned.\n"
18092 " Unfortunately, I have to start at stream 1 and work upward, since\n"
18093 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18094 " that no initial, library-opening call is required. So stream 0 must\n"
18095 " be preallocated, and there is no simple way of determining whether it\n"
18096 " is already in use or not.\n"
18097 "\n"
18098 " Redacted form: plmkstrm(p_strm)\n"
18099 "\n"
18100 " This function is used in examples 1 and 20.\n"
18101 "\n"
18102 "\n"
18103 "\n"
18104 "SYNOPSIS:\n"
18105 "\n"
18106 "plmkstrm(p_strm)\n"
18107 "\n"
18108 "ARGUMENTS:\n"
18109 "\n"
18110 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18111 " number of the created stream.\n"
18112 "\n"
18113 ""},
18114 { "plmtex", _wrap_plmtex, METH_VARARGS, "\n"
18115 "Write text relative to viewport boundaries\n"
18116 "\n"
18117 "DESCRIPTION:\n"
18118 "\n"
18119 " Writes text at a specified position relative to the viewport\n"
18120 " boundaries. Text may be written inside or outside the viewport, but\n"
18121 " is clipped at the subpage boundaries. The reference point of a string\n"
18122 " lies along a line passing through the string at half the height of a\n"
18123 " capital letter. The position of the reference point along this line\n"
18124 " is determined by just, and the position of the reference point\n"
18125 " relative to the viewport is set by disp and pos.\n"
18126 "\n"
18127 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18128 "\n"
18129 "\n"
18130 " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18131 " 26.\n"
18132 "\n"
18133 "\n"
18134 "\n"
18135 "SYNOPSIS:\n"
18136 "\n"
18137 "plmtex(side, disp, pos, just, text)\n"
18138 "\n"
18139 "ARGUMENTS:\n"
18140 "\n"
18141 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18142 " the side of the viewport along which the text is to be written.\n"
18143 " The string must be one of: b: Bottom of viewport, text written\n"
18144 " parallel to edge.\n"
18145 " bv: Bottom of viewport, text written at right angles to edge.\n"
18146 " l: Left of viewport, text written parallel to edge.\n"
18147 " lv: Left of viewport, text written at right angles to edge.\n"
18148 " r: Right of viewport, text written parallel to edge.\n"
18149 " rv: Right of viewport, text written at right angles to edge.\n"
18150 " t: Top of viewport, text written parallel to edge.\n"
18151 " tv: Top of viewport, text written at right angles to edge.\n"
18152 "\n"
18153 "\n"
18154 " disp (PLFLT, input) : Position of the reference point of string,\n"
18155 " measured outwards from the specified viewport edge in units of the\n"
18156 " current character height. Use negative disp to write within the\n"
18157 " viewport.\n"
18158 "\n"
18159 " pos (PLFLT, input) : Position of the reference point of string\n"
18160 " along the specified edge, expressed as a fraction of the length of\n"
18161 " the edge.\n"
18162 "\n"
18163 " just (PLFLT, input) : Specifies the position of the string relative\n"
18164 " to its reference point. If just=0. , the reference point is at\n"
18165 " the left and if just=1. , it is at the right of the string. Other\n"
18166 " values of just give intermediate justifications.\n"
18167 "\n"
18168 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18169 " written out.\n"
18170 "\n"
18171 ""},
18172 { "plmtex3", _wrap_plmtex3, METH_VARARGS, "\n"
18173 "Write text relative to viewport boundaries in 3D plots\n"
18174 "\n"
18175 "DESCRIPTION:\n"
18176 "\n"
18177 " Writes text at a specified position relative to the viewport\n"
18178 " boundaries. Text may be written inside or outside the viewport, but\n"
18179 " is clipped at the subpage boundaries. The reference point of a string\n"
18180 " lies along a line passing through the string at half the height of a\n"
18181 " capital letter. The position of the reference point along this line\n"
18182 " is determined by just, and the position of the reference point\n"
18183 " relative to the viewport is set by disp and pos.\n"
18184 "\n"
18185 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18186 "\n"
18187 " This function is used in example 28.\n"
18188 "\n"
18189 "\n"
18190 "\n"
18191 "SYNOPSIS:\n"
18192 "\n"
18193 "plmtex3(side, disp, pos, just, text)\n"
18194 "\n"
18195 "ARGUMENTS:\n"
18196 "\n"
18197 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18198 " the side of the viewport along which the text is to be written.\n"
18199 " The string should contain one or more of the following characters:\n"
18200 " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18201 " only label the X axis, not both the X and Y axes. x: Label the X\n"
18202 " axis.\n"
18203 " y: Label the Y axis.\n"
18204 " z: Label the Z axis.\n"
18205 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18206 " For X it is the axis that starts at y-min. For Y it is the\n"
18207 " axis that starts at x-min.\n"
18208 " s: Label the secondary axis.\n"
18209 " v: Draw the text perpendicular to the axis.\n"
18210 "\n"
18211 "\n"
18212 " disp (PLFLT, input) : Position of the reference point of string,\n"
18213 " measured outwards from the specified viewport edge in units of the\n"
18214 " current character height. Use negative disp to write within the\n"
18215 " viewport.\n"
18216 "\n"
18217 " pos (PLFLT, input) : Position of the reference point of string\n"
18218 " along the specified edge, expressed as a fraction of the length of\n"
18219 " the edge.\n"
18220 "\n"
18221 " just (PLFLT, input) : Specifies the position of the string relative\n"
18222 " to its reference point. If just=0. , the reference point is at\n"
18223 " the left and if just=1. , it is at the right of the string. Other\n"
18224 " values of just give intermediate justifications.\n"
18225 "\n"
18226 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18227 " written out.\n"
18228 "\n"
18229 ""},
18230 { "plot3d", _wrap_plot3d, METH_VARARGS, "\n"
18231 "Plot 3-d surface plot\n"
18232 "\n"
18233 "DESCRIPTION:\n"
18234 "\n"
18235 " Plots a three-dimensional surface plot within the environment set up\n"
18236 " by plw3d. The surface is defined by the matrix z[\n"
18237 " nx][\n"
18238 " ny] , the point z[i][j] being the value of the function at (\n"
18239 " x[i],\n"
18240 " y[j]). Note that the points in vectors x and y do not need to be\n"
18241 " equally spaced, but must be stored in ascending order. The parameter\n"
18242 " opt controls the way in which the surface is displayed. For further\n"
18243 " details see the PLplot documentation. The only difference between\n"
18244 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18245 " while plot3d only draws the surface as viewed from the top.\n"
18246 "\n"
18247 " Redacted form: plot3d(x, y, z, opt, side)\n"
18248 "\n"
18249 " This function is used in examples 11 and 21.\n"
18250 "\n"
18251 "\n"
18252 "\n"
18253 "SYNOPSIS:\n"
18254 "\n"
18255 "plot3d(x, y, z, nx, ny, opt, side)\n"
18256 "\n"
18257 "ARGUMENTS:\n"
18258 "\n"
18259 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18260 " which the function is evaluated.\n"
18261 "\n"
18262 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18263 " which the function is evaluated.\n"
18264 "\n"
18265 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18266 " plot. Should have dimensions of\n"
18267 " nx by\n"
18268 " ny.\n"
18269 "\n"
18270 " nx (PLINT, input) : Number of x values at which function is\n"
18271 " evaluated.\n"
18272 "\n"
18273 " ny (PLINT, input) : Number of y values at which function is\n"
18274 " evaluated.\n"
18275 "\n"
18276 " opt (PLINT, input) : Determines the way in which the surface is\n"
18277 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18278 " function of x for each value of y[j] .\n"
18279 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18280 " for each value of x[i] .\n"
18281 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18282 " at which function is defined.\n"
18283 "\n"
18284 "\n"
18285 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18286 " should be draw on the figure. If side is true sides are drawn,\n"
18287 " otherwise no sides are drawn.\n"
18288 "\n"
18289 ""},
18290 { "plot3dc", _wrap_plot3dc, METH_VARARGS, "\n"
18291 "Magnitude colored plot surface with contour\n"
18292 "\n"
18293 "DESCRIPTION:\n"
18294 "\n"
18295 " Aside from dropping the\n"
18296 " side functionality this is a more powerful form of plot3d: the surface\n"
18297 " mesh can be colored accordingly to the current z value being plotted,\n"
18298 " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18299 " drawn between the plotted function border and the base XY plane. The\n"
18300 " arguments are identical to those of plmeshc. The only difference\n"
18301 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18302 " the surface, while plot3dc only draws the surface as viewed from the\n"
18303 " top.\n"
18304 "\n"
18305 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18306 "\n"
18307 "\n"
18308 " This function is used in example 21.\n"
18309 "\n"
18310 "\n"
18311 "\n"
18312 "SYNOPSIS:\n"
18313 "\n"
18314 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18315 "\n"
18316 "ARGUMENTS:\n"
18317 "\n"
18318 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18319 " which the function is evaluated.\n"
18320 "\n"
18321 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18322 " which the function is evaluated.\n"
18323 "\n"
18324 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18325 " plot. Should have dimensions of\n"
18326 " nx by\n"
18327 " ny.\n"
18328 "\n"
18329 " nx (PLINT, input) : Number of x values at which function is\n"
18330 " evaluated.\n"
18331 "\n"
18332 " ny (PLINT, input) : Number of y values at which function is\n"
18333 " evaluated.\n"
18334 "\n"
18335 " opt (PLINT, input) : Determines the way in which the surface is\n"
18336 " represented. To specify more than one option just add the options,\n"
18337 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18338 " showing z as a function of x for each value of y[j] .\n"
18339 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18340 " for each value of x[i] .\n"
18341 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18342 " at which function is defined.\n"
18343 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18344 " the z value being plotted. The color is used from the current\n"
18345 " cmap1.\n"
18346 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18347 " using parameters\n"
18348 " nlevel and\n"
18349 " clevel.\n"
18350 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18351 " the borders of the plotted function.\n"
18352 "\n"
18353 "\n"
18354 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18355 " levels.\n"
18356 "\n"
18357 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18358 "\n"
18359 ""},
18360 { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, "\n"
18361 "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18362 "\n"
18363 "DESCRIPTION:\n"
18364 "\n"
18365 " When the implementation is completed this variant of plot3dc (see that\n"
18366 " function's documentation for more details) should be suitable for the\n"
18367 " case where the area of the x, y coordinate grid where z is defined can\n"
18368 " be non-rectangular. The implementation is incomplete so the last 4\n"
18369 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18370 " indexymax; are currently ignored and the functionality is otherwise\n"
18371 " identical to that of plot3dc.\n"
18372 "\n"
18373 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18374 " indexymin, indexymax)\n"
18375 "\n"
18376 "\n"
18377 " This function is not used in any example.\n"
18378 "\n"
18379 "\n"
18380 "\n"
18381 "SYNOPSIS:\n"
18382 "\n"
18383 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18384 "\n"
18385 "ARGUMENTS:\n"
18386 "\n"
18387 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18388 " which the function is evaluated.\n"
18389 "\n"
18390 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18391 " which the function is evaluated.\n"
18392 "\n"
18393 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18394 " plot. Should have dimensions of\n"
18395 " nx by\n"
18396 " ny.\n"
18397 "\n"
18398 " nx (PLINT, input) : Number of x values at which the function is\n"
18399 " evaluated.\n"
18400 "\n"
18401 " ny (PLINT, input) : Number of y values at which the function is\n"
18402 " evaluated.\n"
18403 "\n"
18404 " opt (PLINT, input) : Determines the way in which the surface is\n"
18405 " represented. To specify more than one option just add the options,\n"
18406 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18407 " showing z as a function of x for each value of y[j] .\n"
18408 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18409 " for each value of x[i] .\n"
18410 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18411 " at which function is defined.\n"
18412 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18413 " the z value being plotted. The color is used from the current\n"
18414 " cmap1.\n"
18415 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18416 " using parameters\n"
18417 " nlevel and\n"
18418 " clevel.\n"
18419 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18420 " the borders of the plotted function.\n"
18421 "\n"
18422 "\n"
18423 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18424 " levels.\n"
18425 "\n"
18426 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18427 "\n"
18428 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18429 " corresponds to the first x index where z is defined.\n"
18430 "\n"
18431 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18432 " which corresponds (by convention) to one more than the last x\n"
18433 " index value where z is defined.\n"
18434 "\n"
18435 " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18436 " values which all must be ≥ 0. These values are the first y index\n"
18437 " where z is defined for a particular x index in the range from\n"
18438 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18439 " indexxmax.\n"
18440 "\n"
18441 " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18442 " values which all must be ≤ ny. These values correspond (by\n"
18443 " convention) to one more than the last y index where z is defined\n"
18444 " for a particular x index in the range from indexxmin to indexxmax\n"
18445 " - 1. The dimension of indexymax is indexxmax.\n"
18446 "\n"
18447 ""},
18448 { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, "\n"
18449 "Plot shaded 3-d surface plot\n"
18450 "\n"
18451 "DESCRIPTION:\n"
18452 "\n"
18453 " Plots a three-dimensional shaded surface plot within the environment\n"
18454 " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18455 " z[\n"
18456 " nx][\n"
18457 " ny], the point z[i][j] being the value of the function at (\n"
18458 " x[i],\n"
18459 " y[j]). Note that the points in vectors x and y do not need to be\n"
18460 " equally spaced, but must be stored in ascending order. For further\n"
18461 " details see the PLplot documentation.\n"
18462 "\n"
18463 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18464 "\n"
18465 " This function is not used in any examples.\n"
18466 "\n"
18467 "\n"
18468 "\n"
18469 "SYNOPSIS:\n"
18470 "\n"
18471 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18472 "\n"
18473 "ARGUMENTS:\n"
18474 "\n"
18475 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18476 " which the function is evaluated.\n"
18477 "\n"
18478 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18479 " which the function is evaluated.\n"
18480 "\n"
18481 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18482 " plot. Should have dimensions of\n"
18483 " nx by\n"
18484 " ny.\n"
18485 "\n"
18486 " nx (PLINT, input) : Number of x values at which function is\n"
18487 " evaluated.\n"
18488 "\n"
18489 " ny (PLINT, input) : Number of y values at which function is\n"
18490 " evaluated.\n"
18491 "\n"
18492 " opt (PLINT, input) : Determines the way in which the surface is\n"
18493 " represented. To specify more than one option just add the options,\n"
18494 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18495 " connecting points at which function is defined.\n"
18496 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18497 " using parameters\n"
18498 " nlevel and\n"
18499 " clevel.\n"
18500 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18501 " using parameters\n"
18502 " nlevel and\n"
18503 " clevel.\n"
18504 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18505 " the borders of the plotted function.\n"
18506 " opt=MAG_COLOR : the surface is colored according to the value\n"
18507 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18508 " according to the intensity of the reflected light in the\n"
18509 " surface from a light source whose position is set using\n"
18510 " pllightsource.\n"
18511 "\n"
18512 "\n"
18513 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18514 " levels.\n"
18515 "\n"
18516 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18517 "\n"
18518 ""},
18519 { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, "\n"
18520 "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18521 "\n"
18522 "DESCRIPTION:\n"
18523 "\n"
18524 " This variant of plsurf3d (see that function's documentation for more\n"
18525 " details) should be suitable for the case where the area of the x, y\n"
18526 " coordinate grid where z is defined can be non-rectangular. The limits\n"
18527 " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18528 " indexymin, and indexymax.\n"
18529 "\n"
18530 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18531 " indexymax)\n"
18532 "\n"
18533 " This function is used in example 8.\n"
18534 "\n"
18535 "\n"
18536 "\n"
18537 "SYNOPSIS:\n"
18538 "\n"
18539 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18540 "\n"
18541 "ARGUMENTS:\n"
18542 "\n"
18543 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18544 " which the function is evaluated.\n"
18545 "\n"
18546 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18547 " which the function is evaluated.\n"
18548 "\n"
18549 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18550 " plot. Should have dimensions of\n"
18551 " nx by\n"
18552 " ny.\n"
18553 "\n"
18554 " nx (PLINT, input) : Number of x values at which function is\n"
18555 " evaluated.\n"
18556 "\n"
18557 " ny (PLINT, input) : Number of y values at which function is\n"
18558 " evaluated.\n"
18559 "\n"
18560 " opt (PLINT, input) : Determines the way in which the surface is\n"
18561 " represented. To specify more than one option just add the options,\n"
18562 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18563 " connecting points at which function is defined.\n"
18564 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18565 " using parameters\n"
18566 " nlevel and\n"
18567 " clevel.\n"
18568 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18569 " using parameters\n"
18570 " nlevel and\n"
18571 " clevel.\n"
18572 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18573 " the borders of the plotted function.\n"
18574 " opt=MAG_COLOR : the surface is colored according to the value\n"
18575 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18576 " according to the intensity of the reflected light in the\n"
18577 " surface from a light source whose position is set using\n"
18578 " pllightsource.\n"
18579 "\n"
18580 "\n"
18581 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18582 " levels.\n"
18583 "\n"
18584 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18585 "\n"
18586 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18587 " corresponds to the first x index where z is defined.\n"
18588 "\n"
18589 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18590 " which corresponds (by convention) to one more than the last x\n"
18591 " index value where z is defined.\n"
18592 "\n"
18593 " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
18594 " values which all must be ≥ 0. These values are the first y index\n"
18595 " where z is defined for a particular x index in the range from\n"
18596 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18597 " indexxmax.\n"
18598 "\n"
18599 " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
18600 " values which all must be ≤ ny. These values correspond (by\n"
18601 " convention) to one more than the last y index where z is defined\n"
18602 " for a particular x index in the range from indexxmin to indexxmax\n"
18603 " - 1. The dimension of indexymax is indexxmax.\n"
18604 "\n"
18605 ""},
18606 { "plparseopts", _wrap_plparseopts, METH_VARARGS, "\n"
18607 "Parse command-line arguments\n"
18608 "\n"
18609 "DESCRIPTION:\n"
18610 "\n"
18611 " Parse command-line arguments.\n"
18612 "\n"
18613 " plparseopts removes all recognized flags (decreasing argc\n"
18614 " accordingly), so that invalid input may be readily detected. It can\n"
18615 " also be used to process user command line flags. The user can merge\n"
18616 " an option table of type PLOptionTable into the internal option table\n"
18617 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
18618 " the external table(s) be parsed by calling plClearOpts before\n"
18619 " plMergeOpts.\n"
18620 "\n"
18621 " The default action taken by plparseopts is as follows:\n"
18622 " Returns with an error if an unrecognized option or badly formed\n"
18623 " option-value pair are encountered.\n"
18624 " Returns immediately (return code 0) when the first non-option command\n"
18625 " line argument is found.\n"
18626 " Returns with the return code of the option handler, if one was called.\n"
18627 "\n"
18628 " Deletes command line arguments from argv list as they are found, and\n"
18629 " decrements argc accordingly.\n"
18630 " Does not show \"invisible\" options in usage or help messages.\n"
18631 " Assumes the program name is contained in argv[0].\n"
18632 "\n"
18633 " These behaviors may be controlled through the\n"
18634 " mode argument.\n"
18635 "\n"
18636 " Redacted form: General: plparseopts(argv, mode)\n"
18637 "\n"
18638 "\n"
18639 " This function is used in all of the examples.\n"
18640 "\n"
18641 "\n"
18642 "\n"
18643 "SYNOPSIS:\n"
18644 "\n"
18645 "PLINT plparseopts(p_argc, argv, mode)\n"
18646 "\n"
18647 "ARGUMENTS:\n"
18648 "\n"
18649 " p_argc (int *, input/output) : Number of arguments.\n"
18650 "\n"
18651 " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
18652 " strings containing *p_argc command-line arguments.\n"
18653 "\n"
18654 " mode (PLINT, input) : Parsing mode with the following\n"
18655 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
18656 " and all error messages enabled, including program exit when an\n"
18657 " error occurs. Anything on the command line that isn't recognized\n"
18658 " as a valid option or option argument is flagged as an error.\n"
18659 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
18660 " of errors.\n"
18661 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
18662 " arguments.\n"
18663 " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
18664 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
18665 " pointer to the program name.\n"
18666 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
18667 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
18668 " unrecognized arguments.\n"
18669 "\n"
18670 ""},
18671 { "plpat", _wrap_plpat, METH_VARARGS, "\n"
18672 "Set area line fill pattern\n"
18673 "\n"
18674 "DESCRIPTION:\n"
18675 "\n"
18676 " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
18677 " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
18678 " inclinations and spacings. The arguments to this routine are the\n"
18679 " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
18680 " elements) specifying the inclinations in tenths of a degree and the\n"
18681 " spacing in micrometers. (See also plpsty)\n"
18682 "\n"
18683 " Redacted form: General: plpat(inc, del)\n"
18684 "\n"
18685 "\n"
18686 " This function is used in example 15.\n"
18687 "\n"
18688 "\n"
18689 "\n"
18690 "SYNOPSIS:\n"
18691 "\n"
18692 "plpat(nlin, inc, del)\n"
18693 "\n"
18694 "ARGUMENTS:\n"
18695 "\n"
18696 " nlin (PLINT, input) : Number of sets of lines making up the\n"
18697 " pattern, either 1 or 2.\n"
18698 "\n"
18699 " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18700 " inclination in tenths of a degree. (Should be between -900 and\n"
18701 " 900).\n"
18702 "\n"
18703 " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
18704 " spacing in micrometers between the lines making up the pattern.\n"
18705 "\n"
18706 ""},
18707 { "plpath", _wrap_plpath, METH_VARARGS, "\n"
18708 "Draw a line between two points, accounting for coordinate transforms\n"
18709 "\n"
18710 "DESCRIPTION:\n"
18711 "\n"
18712 " Joins the point (\n"
18713 " x1,\n"
18714 " y1) to (\n"
18715 " x2,\n"
18716 " y2) . If a global coordinate transform is defined then the line is\n"
18717 " broken in to n segments to approximate the path. If no transform is\n"
18718 " defined then this simply acts like a call to pljoin.\n"
18719 "\n"
18720 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
18721 "\n"
18722 " This function is used in example 22.\n"
18723 "\n"
18724 "\n"
18725 "\n"
18726 "SYNOPSIS:\n"
18727 "\n"
18728 "plpath(n, x1, y1, x2, y2)\n"
18729 "\n"
18730 "ARGUMENTS:\n"
18731 "\n"
18732 " n (PLINT, input) : number of points to use to approximate the path.\n"
18733 "\n"
18734 " x1 (PLFLT, input) : x coordinate of first point.\n"
18735 "\n"
18736 " y1 (PLFLT, input) : y coordinate of first point.\n"
18737 "\n"
18738 " x2 (PLFLT, input) : x coordinate of second point.\n"
18739 "\n"
18740 " y2 (PLFLT, input) : y coordinate of second point.\n"
18741 "\n"
18742 ""},
18743 { "plpoin", _wrap_plpoin, METH_VARARGS, "\n"
18744 "Plot a glyph at the specified points\n"
18745 "\n"
18746 "DESCRIPTION:\n"
18747 "\n"
18748 " Plot a glyph at the specified points. (This function is largely\n"
18749 " superseded by plstring which gives access to many[!] more glyphs.)\n"
18750 " code=-1 means try to just draw a point. Right now it's just a move\n"
18751 " and a draw at the same place. Not ideal, since a sufficiently\n"
18752 " intelligent output device may optimize it away, or there may be faster\n"
18753 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18754 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18755 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18756 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18757 " code <= 127 the corresponding printable ASCII character is plotted.\n"
18758 "\n"
18759 " Redacted form: plpoin(x, y, code)\n"
18760 "\n"
18761 " This function is used in examples 1, 6, 14, and 29.\n"
18762 "\n"
18763 "\n"
18764 "\n"
18765 "SYNOPSIS:\n"
18766 "\n"
18767 "plpoin(n, x, y, code)\n"
18768 "\n"
18769 "ARGUMENTS:\n"
18770 "\n"
18771 " n (PLINT, input) : Number of points in the x and y vectors.\n"
18772 "\n"
18773 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18774 " points.\n"
18775 "\n"
18776 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18777 " points.\n"
18778 "\n"
18779 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18780 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18781 " each of the n points.\n"
18782 "\n"
18783 ""},
18784 { "plpoin3", _wrap_plpoin3, METH_VARARGS, "\n"
18785 "Plot a glyph at the specified 3D points\n"
18786 "\n"
18787 "DESCRIPTION:\n"
18788 "\n"
18789 " Plot a glyph at the specified 3D points. (This function is largely\n"
18790 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
18791 " Set up the call to this function similar to what is done for plline3.\n"
18792 " code=-1 means try to just draw a point. Right now it's just a move\n"
18793 " and a draw at the same place. Not ideal, since a sufficiently\n"
18794 " intelligent output device may optimize it away, or there may be faster\n"
18795 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
18796 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
18797 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
18798 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
18799 " code <= 127 the corresponding printable ASCII character is plotted.\n"
18800 "\n"
18801 " Redacted form: plpoin3(x, y, z, code)\n"
18802 "\n"
18803 " This function is not used in any example.\n"
18804 "\n"
18805 "\n"
18806 "\n"
18807 "SYNOPSIS:\n"
18808 "\n"
18809 "plpoin3(n, x, y, z, code)\n"
18810 "\n"
18811 "ARGUMENTS:\n"
18812 "\n"
18813 " n (PLINT, input) : Number of points in the x and y vectors.\n"
18814 "\n"
18815 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18816 " points.\n"
18817 "\n"
18818 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18819 " points.\n"
18820 "\n"
18821 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18822 " points.\n"
18823 "\n"
18824 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
18825 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
18826 " each of the n points.\n"
18827 "\n"
18828 ""},
18829 { "plpoly3", _wrap_plpoly3, METH_VARARGS, "\n"
18830 "Draw a polygon in 3 space\n"
18831 "\n"
18832 "DESCRIPTION:\n"
18833 "\n"
18834 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
18835 " like plline3, but differs from that function in that plpoly3 attempts\n"
18836 " to determine if the polygon is viewable depending on the order of the\n"
18837 " points within the vector and the value of ifcc. If the back of\n"
18838 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
18839 " you want, then use plline3 instead.\n"
18840 "\n"
18841 " The points are assumed to be in a plane, and the directionality of the\n"
18842 " plane is determined from the first three points. Additional points do\n"
18843 " not have to lie on the plane defined by the first three, but if they\n"
18844 " do not, then the determination of visibility obviously can't be 100%\n"
18845 " accurate... So if you're 3 space polygons are too far from planar,\n"
18846 " consider breaking them into smaller polygons. 3 points define a plane\n"
18847 " :-).\n"
18848 "\n"
18849 " Bugs: If one of the first two segments is of zero length, or if they\n"
18850 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
18851 " being correct. Avoid such situations :-). See x18c.c for an example\n"
18852 " of this problem. (Search for 20.1).\n"
18853 "\n"
18854 " Redacted form: plpoly3(x, y, z, code)\n"
18855 "\n"
18856 " This function is used in example 18.\n"
18857 "\n"
18858 "\n"
18859 "\n"
18860 "SYNOPSIS:\n"
18861 "\n"
18862 "plpoly3(n, x, y, z, draw, ifcc)\n"
18863 "\n"
18864 "ARGUMENTS:\n"
18865 "\n"
18866 " n (PLINT, input) : Number of points defining line.\n"
18867 "\n"
18868 " x (PLFLT_VECTOR, input) : A vector containing\n"
18869 " n x coordinates of points.\n"
18870 "\n"
18871 " y (PLFLT_VECTOR, input) : A vector containing\n"
18872 " n y coordinates of points.\n"
18873 "\n"
18874 " z (PLFLT_VECTOR, input) : A vector containing\n"
18875 " n z coordinates of points.\n"
18876 "\n"
18877 " draw (PLBOOL_VECTOR, input) : A vector containing\n"
18878 " n-1 Boolean values which control drawing the segments of the polygon.\n"
18879 " If draw[i] is true, then the polygon segment from index [i] to\n"
18880 " [i+1] is drawn, otherwise, not.\n"
18881 "\n"
18882 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
18883 " polygon is determined by assuming the points are laid out in a\n"
18884 " counter-clockwise order. Otherwise, the directionality of the\n"
18885 " polygon is determined by assuming the points are laid out in a\n"
18886 " clockwise order.\n"
18887 "\n"
18888 ""},
18889 { "plprec", _wrap_plprec, METH_VARARGS, "\n"
18890 "Set precision in numeric labels\n"
18891 "\n"
18892 "DESCRIPTION:\n"
18893 "\n"
18894 " Sets the number of places after the decimal point in numeric labels.\n"
18895 "\n"
18896 " Redacted form: plprec(setp, prec)\n"
18897 "\n"
18898 " This function is used in example 29.\n"
18899 "\n"
18900 "\n"
18901 "\n"
18902 "SYNOPSIS:\n"
18903 "\n"
18904 "plprec(setp, prec)\n"
18905 "\n"
18906 "ARGUMENTS:\n"
18907 "\n"
18908 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
18909 " automatically determines the number of places to use after the\n"
18910 " decimal point in numeric labels (like those used to label axes).\n"
18911 " If setp is 1 then prec sets the number of places.\n"
18912 "\n"
18913 " prec (PLINT, input) : The number of characters to draw after the\n"
18914 " decimal point in numeric labels.\n"
18915 "\n"
18916 ""},
18917 { "plpsty", _wrap_plpsty, METH_O, "\n"
18918 "Select area fill pattern\n"
18919 "\n"
18920 "DESCRIPTION:\n"
18921 "\n"
18922 " If\n"
18923 " patt is zero or less use either a hardware solid fill if the drivers\n"
18924 " have that capability (virtually all do) or fall back to a software\n"
18925 " emulation of a solid fill using the eighth area line fill pattern. If\n"
18926 " 0 <\n"
18927 " patt <= 8, then select one of eight predefined area line fill patterns\n"
18928 " to use (see plpat if you desire other patterns).\n"
18929 "\n"
18930 " Redacted form: plpsty(patt)\n"
18931 "\n"
18932 " This function is used in examples 12, 13, 15, 16, and 25.\n"
18933 "\n"
18934 "\n"
18935 "\n"
18936 "SYNOPSIS:\n"
18937 "\n"
18938 "plpsty(patt)\n"
18939 "\n"
18940 "ARGUMENTS:\n"
18941 "\n"
18942 " patt (PLINT, input) : The desired pattern index. If\n"
18943 " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
18944 " above) used. For\n"
18945 " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
18946 " line fill capability itself (most deliberately do not so that line\n"
18947 " fill patterns look identical for those drivers), the patterns\n"
18948 " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
18949 " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
18950 " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
18951 " (8) lines at both 45 degrees and -45 degrees.\n"
18952 "\n"
18953 ""},
18954 { "plptex", _wrap_plptex, METH_VARARGS, "\n"
18955 "Write text inside the viewport\n"
18956 "\n"
18957 "DESCRIPTION:\n"
18958 "\n"
18959 " Writes text at a specified position and inclination within the\n"
18960 " viewport. Text is clipped at the viewport boundaries. The reference\n"
18961 " point of a string lies along a line passing through the string at half\n"
18962 " the height of a capital letter. The position of the reference point\n"
18963 " along this line is determined by just, the reference point is placed\n"
18964 " at world coordinates (\n"
18965 " x,\n"
18966 " y) within the viewport. The inclination of the string is specified\n"
18967 " in terms of differences of world coordinates making it easy to write\n"
18968 " text parallel to a line in a graph.\n"
18969 "\n"
18970 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
18971 "\n"
18972 " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
18973 "\n"
18974 "\n"
18975 "\n"
18976 "SYNOPSIS:\n"
18977 "\n"
18978 "plptex(x, y, dx, dy, just, text)\n"
18979 "\n"
18980 "ARGUMENTS:\n"
18981 "\n"
18982 " x (PLFLT, input) : x coordinate of reference point of string.\n"
18983 "\n"
18984 " y (PLFLT, input) : y coordinate of reference point of string.\n"
18985 "\n"
18986 " dx (PLFLT, input) : Together with dy, this specifies the\n"
18987 " inclination of the string. The baseline of the string is parallel\n"
18988 " to a line joining (\n"
18989 " x,\n"
18990 " y) to (\n"
18991 " x+\n"
18992 " dx,\n"
18993 " y+\n"
18994 " dy) .\n"
18995 "\n"
18996 " dy (PLFLT, input) : Together with dx, this specifies the\n"
18997 " inclination of the string.\n"
18998 "\n"
18999 " just (PLFLT, input) : Specifies the position of the string relative\n"
19000 " to its reference point. If just=0. , the reference point is at\n"
19001 " the left and if just=1. , it is at the right of the string. Other\n"
19002 " values of just give intermediate justifications.\n"
19003 "\n"
19004 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19005 " written out.\n"
19006 "\n"
19007 ""},
19008 { "plptex3", _wrap_plptex3, METH_VARARGS, "\n"
19009 "Write text inside the viewport of a 3D plot\n"
19010 "\n"
19011 "DESCRIPTION:\n"
19012 "\n"
19013 " Writes text at a specified position and inclination and with a\n"
19014 " specified shear within the viewport. Text is clipped at the viewport\n"
19015 " boundaries. The reference point of a string lies along a line passing\n"
19016 " through the string at half the height of a capital letter. The\n"
19017 " position of the reference point along this line is determined by just,\n"
19018 " and the reference point is placed at world coordinates (\n"
19019 " wx,\n"
19020 " wy,\n"
19021 " wz) within the viewport. The inclination and shear of the string is\n"
19022 " specified in terms of differences of world coordinates making it easy\n"
19023 " to write text parallel to a line in a graph.\n"
19024 "\n"
19025 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19026 "\n"
19027 " This function is used in example 28.\n"
19028 "\n"
19029 "\n"
19030 "\n"
19031 "SYNOPSIS:\n"
19032 "\n"
19033 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19034 "\n"
19035 "ARGUMENTS:\n"
19036 "\n"
19037 " wx (PLFLT, input) : x world coordinate of reference point of\n"
19038 " string.\n"
19039 "\n"
19040 " wy (PLFLT, input) : y world coordinate of reference point of\n"
19041 " string.\n"
19042 "\n"
19043 " wz (PLFLT, input) : z world coordinate of reference point of\n"
19044 " string.\n"
19045 "\n"
19046 " dx (PLFLT, input) : Together with dy and\n"
19047 " dz , this specifies the inclination of the string. The baseline of\n"
19048 " the string is parallel to a line joining (\n"
19049 " x,\n"
19050 " y,\n"
19051 " z) to (\n"
19052 " x+\n"
19053 " dx,\n"
19054 " y+\n"
19055 " dy,\n"
19056 " z+\n"
19057 " dz) .\n"
19058 "\n"
19059 " dy (PLFLT, input) : Together with dx and\n"
19060 " dz, this specifies the inclination of the string.\n"
19061 "\n"
19062 " dz (PLFLT, input) : Together with dx and\n"
19063 " dy, this specifies the inclination of the string.\n"
19064 "\n"
19065 " sx (PLFLT, input) : Together with sy and\n"
19066 " sz , this specifies the shear of the string. The string is sheared so\n"
19067 " that the characters are vertically parallel to a line joining (\n"
19068 " x,\n"
19069 " y,\n"
19070 " z) to (\n"
19071 " x+\n"
19072 " sx,\n"
19073 " y+\n"
19074 " sy,\n"
19075 " z+\n"
19076 " sz) . If sx =\n"
19077 " sy =\n"
19078 " sz = 0.) then the text is not sheared.\n"
19079 "\n"
19080 " sy (PLFLT, input) : Together with sx and\n"
19081 " sz, this specifies shear of the string.\n"
19082 "\n"
19083 " sz (PLFLT, input) : Together with sx and\n"
19084 " sy, this specifies shear of the string.\n"
19085 "\n"
19086 " just (PLFLT, input) : Specifies the position of the string relative\n"
19087 " to its reference point. If just=0. , the reference point is at\n"
19088 " the left and if just=1. , it is at the right of the string. Other\n"
19089 " values of just give intermediate justifications.\n"
19090 "\n"
19091 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19092 " written out.\n"
19093 "\n"
19094 ""},
19095 { "plrandd", _wrap_plrandd, METH_NOARGS, "\n"
19096 "Random number generator returning a real random number in the range [0,1]\n"
19097 "\n"
19098 "DESCRIPTION:\n"
19099 "\n"
19100 " Random number generator returning a real random number in the range\n"
19101 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19102 " / compilers provide their own random number generator, and so this is\n"
19103 " provided purely for convenience and to give a consistent random number\n"
19104 " generator across all languages supported by PLplot. This is\n"
19105 " particularly useful for comparing results from the test suite of\n"
19106 " examples.\n"
19107 "\n"
19108 " Redacted form: plrandd()\n"
19109 "\n"
19110 " This function is used in examples 17 and 21.\n"
19111 "\n"
19112 "\n"
19113 "\n"
19114 "SYNOPSIS:\n"
19115 "\n"
19116 "plrandd()\n"
19117 "\n"
19118 ""},
19119 { "plreplot", _wrap_plreplot, METH_NOARGS, "\n"
19120 "Replays contents of plot buffer to current device/file\n"
19121 "\n"
19122 "DESCRIPTION:\n"
19123 "\n"
19124 " Replays contents of plot buffer to current device/file.\n"
19125 "\n"
19126 " Redacted form: plreplot()\n"
19127 "\n"
19128 " This function is used in example 1,20.\n"
19129 "\n"
19130 "\n"
19131 "\n"
19132 "SYNOPSIS:\n"
19133 "\n"
19134 "plreplot()\n"
19135 "\n"
19136 ""},
19137 { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, "\n"
19138 "Convert RGB color to HLS\n"
19139 "\n"
19140 "DESCRIPTION:\n"
19141 "\n"
19142 " Convert RGB color coordinates to HLS\n"
19143 "\n"
19144 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19145 "\n"
19146 "\n"
19147 " This function is used in example 2.\n"
19148 "\n"
19149 "\n"
19150 "\n"
19151 "SYNOPSIS:\n"
19152 "\n"
19153 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19154 "\n"
19155 "ARGUMENTS:\n"
19156 "\n"
19157 " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19158 "\n"
19159 " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19160 "\n"
19161 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19162 "\n"
19163 " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19164 " degrees (0.0-360.0) on the color cylinder.\n"
19165 "\n"
19166 " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19167 " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19168 " cylinder.\n"
19169 "\n"
19170 " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19171 " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19172 " cylinder.\n"
19173 "\n"
19174 ""},
19175 { "plschr", _wrap_plschr, METH_VARARGS, "\n"
19176 "Set character size\n"
19177 "\n"
19178 "DESCRIPTION:\n"
19179 "\n"
19180 " This sets up the size of all subsequent characters drawn. The actual\n"
19181 " height of a character is the product of the default character size and\n"
19182 " a scaling factor.\n"
19183 "\n"
19184 " Redacted form: plschr(def, scale)\n"
19185 "\n"
19186 " This function is used in examples 2, 13, 23, and 24.\n"
19187 "\n"
19188 "\n"
19189 "\n"
19190 "SYNOPSIS:\n"
19191 "\n"
19192 "plschr(def, scale)\n"
19193 "\n"
19194 "ARGUMENTS:\n"
19195 "\n"
19196 " def (PLFLT, input) : The default height of a character in\n"
19197 " millimeters, should be set to zero if the default height is to\n"
19198 " remain unchanged. For rasterized drivers the dx and dy values\n"
19199 " specified in plspage are used to convert from mm to pixels (note\n"
19200 " the different unit systems used). This dpi aware scaling is not\n"
19201 " implemented for all drivers yet.\n"
19202 "\n"
19203 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19204 " actual character height.\n"
19205 "\n"
19206 ""},
19207 { "plscmap0", _wrap_plscmap0, METH_VARARGS, "\n"
19208 "Set cmap0 colors by 8-bit RGB values\n"
19209 "\n"
19210 "DESCRIPTION:\n"
19211 "\n"
19212 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19213 " documentation). This sets the entire color map -- only as many colors\n"
19214 " as specified will be allocated.\n"
19215 "\n"
19216 " Redacted form: plscmap0(r, g, b)\n"
19217 "\n"
19218 " This function is used in examples 2 and 24.\n"
19219 "\n"
19220 "\n"
19221 "\n"
19222 "SYNOPSIS:\n"
19223 "\n"
19224 "plscmap0(r, g, b, ncol0)\n"
19225 "\n"
19226 "ARGUMENTS:\n"
19227 "\n"
19228 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19229 " integers (0-255) representing the degree of red in the color.\n"
19230 "\n"
19231 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19232 " integers (0-255) representing the degree of green in the color.\n"
19233 "\n"
19234 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19235 " integers (0-255) representing the degree of blue in the color.\n"
19236 "\n"
19237 " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19238 "\n"
19239 ""},
19240 { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, "\n"
19241 "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19242 "\n"
19243 "DESCRIPTION:\n"
19244 "\n"
19245 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19246 " and PLFLT alpha transparency value. This sets the entire color map --\n"
19247 " only as many colors as specified will be allocated.\n"
19248 "\n"
19249 " Redacted form: plscmap0a(r, g, b, alpha)\n"
19250 "\n"
19251 " This function is used in examples 30.\n"
19252 "\n"
19253 "\n"
19254 "\n"
19255 "SYNOPSIS:\n"
19256 "\n"
19257 "plscmap0a(r, g, b, alpha, ncol0)\n"
19258 "\n"
19259 "ARGUMENTS:\n"
19260 "\n"
19261 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19262 " integers (0-255) representing the degree of red in the color.\n"
19263 "\n"
19264 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19265 " integers (0-255) representing the degree of green in the color.\n"
19266 "\n"
19267 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19268 " integers (0-255) representing the degree of blue in the color.\n"
19269 "\n"
19270 " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19271 " representing the alpha transparency of the color.\n"
19272 "\n"
19273 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19274 " vectors.\n"
19275 "\n"
19276 ""},
19277 { "plscmap0n", _wrap_plscmap0n, METH_O, "\n"
19278 "Set number of colors in cmap0\n"
19279 "\n"
19280 "DESCRIPTION:\n"
19281 "\n"
19282 " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19283 " (or reallocate) cmap0, and fill with default values for those colors\n"
19284 " not previously allocated. The first 16 default colors are given in\n"
19285 " the plcol0 documentation. For larger indices the default color is\n"
19286 " red.\n"
19287 "\n"
19288 " The drivers are not guaranteed to support more than 16 colors.\n"
19289 "\n"
19290 " Redacted form: plscmap0n(ncol0)\n"
19291 "\n"
19292 " This function is used in examples 15, 16, and 24.\n"
19293 "\n"
19294 "\n"
19295 "\n"
19296 "SYNOPSIS:\n"
19297 "\n"
19298 "plscmap0n(ncol0)\n"
19299 "\n"
19300 "ARGUMENTS:\n"
19301 "\n"
19302 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19303 " the cmap0 palette. If this number is zero or less, then the value\n"
19304 " from the previous call to plscmap0n is used and if there is no\n"
19305 " previous call, then a default value is used.\n"
19306 "\n"
19307 ""},
19308 { "plscmap1", _wrap_plscmap1, METH_VARARGS, "\n"
19309 "Set opaque RGB cmap1 colors values\n"
19310 "\n"
19311 "DESCRIPTION:\n"
19312 "\n"
19313 " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19314 " vector values. This function also sets the number of cmap1 colors.\n"
19315 " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19316 " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19317 " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19318 " to\n"
19319 " ncol1-1. So in order for this continuous color model to work\n"
19320 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19321 " that these RGB vectors are continuous functions of their integer\n"
19322 " indices.\n"
19323 "\n"
19324 " Redacted form: plscmap1(r, g, b)\n"
19325 "\n"
19326 " This function is used in example 31.\n"
19327 "\n"
19328 "\n"
19329 "\n"
19330 "SYNOPSIS:\n"
19331 "\n"
19332 "plscmap1(r, g, b, ncol1)\n"
19333 "\n"
19334 "ARGUMENTS:\n"
19335 "\n"
19336 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19337 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19338 " color as a continuous function of the integer index of the vector.\n"
19339 "\n"
19340 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19341 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19342 " color as a continuous function of the integer index of the vector.\n"
19343 "\n"
19344 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19345 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19346 " color as a continuous function of the integer index of the vector.\n"
19347 "\n"
19348 " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19349 "\n"
19350 ""},
19351 { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, "\n"
19352 "Set semitransparent cmap1 RGBA colors.\n"
19353 "\n"
19354 "DESCRIPTION:\n"
19355 "\n"
19356 " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19357 " RGBA vector values. This function also sets the number of cmap1\n"
19358 " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19359 " floating-point index in the range from 0.0-1.0 which is linearly\n"
19360 " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19361 " vectors in the range from 0 to\n"
19362 " ncol1-1. So in order for this continuous color model to work\n"
19363 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19364 " that these RGBA vectors are continuous functions of their integer\n"
19365 " indices.\n"
19366 "\n"
19367 " Redacted form: plscmap1a(r, g, b, alpha)\n"
19368 "\n"
19369 " This function is used in example 31.\n"
19370 "\n"
19371 "\n"
19372 "\n"
19373 "SYNOPSIS:\n"
19374 "\n"
19375 "plscmap1a(r, g, b, alpha, ncol1)\n"
19376 "\n"
19377 "ARGUMENTS:\n"
19378 "\n"
19379 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19380 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19381 " color as a continuous function of the integer index of the vector.\n"
19382 "\n"
19383 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19384 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19385 " color as a continuous function of the integer index of the vector.\n"
19386 "\n"
19387 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19388 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19389 " color as a continuous function of the integer index of the vector.\n"
19390 "\n"
19391 " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19392 " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19393 " completely transparent and 1.0 corresponds to completely opaque)\n"
19394 " the alpha transparency of the color as a continuous function of\n"
19395 " the integer index of the vector.\n"
19396 "\n"
19397 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19398 " vectors.\n"
19399 "\n"
19400 ""},
19401 { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, "\n"
19402 "Set cmap1 colors using a piece-wise linear relationship\n"
19403 "\n"
19404 "DESCRIPTION:\n"
19405 "\n"
19406 " Set cmap1 colors using a piece-wise linear relationship between the\n"
19407 " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19408 " (see the PLplot documentation). May be called at any time.\n"
19409 "\n"
19410 " The idea here is to specify a number of control points that define the\n"
19411 " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19412 " these points, linear interpolation is used which gives a smooth\n"
19413 " variation of color with intensity index. Any number of control points\n"
19414 " may be specified, located at arbitrary positions, although typically 2\n"
19415 " - 4 are enough. Another way of stating this is that we are traversing\n"
19416 " a given number of lines through HLS or RGB space as we move through\n"
19417 " cmap1 intensity indices. The control points at the minimum and\n"
19418 " maximum position (0 and 1) must always be specified. By adding more\n"
19419 " control points you can get more variation. One good technique for\n"
19420 " plotting functions that vary about some expected average is to use an\n"
19421 " additional 2 control points in the center (position ~= 0.5) that are\n"
19422 " the same lightness as the background (typically white for paper\n"
19423 " output, black for crt), and same hue as the boundary control points.\n"
19424 " This allows the highs and lows to be very easily distinguished.\n"
19425 "\n"
19426 " Each control point must specify the cmap1 intensity index and the\n"
19427 " associated three coordinates in HLS or RGB space. The first point\n"
19428 " must correspond to position = 0, and the last to position = 1.\n"
19429 "\n"
19430 " If RGB colors are provided then the interpolation takes place in RGB\n"
19431 " space and is trivial. However if HLS colors are provided then, because\n"
19432 " of the circular nature of the color wheel for the hue coordinate, the\n"
19433 " interpolation could be performed in either direction around the color\n"
19434 " wheel. The default behaviour is for the hue to be linearly\n"
19435 " interpolated ignoring this circular property of hue. So for example,\n"
19436 " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19437 " green and cyan. If instead you wish to interpolate the other way\n"
19438 " around the color wheel you have two options. You may provide hues\n"
19439 " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19440 " for red the interpolation will proceed via magenta. Alternatively you\n"
19441 " can utilise the alt_hue_path variable to reverse the direction of\n"
19442 " interpolation if you need to provide hues within the [0-360) range.\n"
19443 "\n"
19444 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19445 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19446 " -120]falsegreen-yellow-red-magenta-blue[240\n"
19447 " 480]falseblue-magenta-red-yellow-green[120\n"
19448 " 240]truegreen-yellow-red-magenta-blue[240\n"
19449 " 120]trueblue-magenta-red-yellow-green\n"
19450 "\n"
19451 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19452 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19453 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19454 "\n"
19455 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19456 " alt_hue_path)\n"
19457 "\n"
19458 " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19459 "\n"
19460 "\n"
19461 "\n"
19462 "SYNOPSIS:\n"
19463 "\n"
19464 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19465 "\n"
19466 "ARGUMENTS:\n"
19467 "\n"
19468 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19469 "\n"
19470 " npts (PLINT, input) : number of control points\n"
19471 "\n"
19472 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19473 " intensity index (0.0-1.0) in ascending order for each control\n"
19474 " point.\n"
19475 "\n"
19476 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19477 " coordinate (H or R) for each control point.\n"
19478 "\n"
19479 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19480 " coordinate (L or G) for each control point.\n"
19481 "\n"
19482 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19483 " coordinate (S or B) for each control point.\n"
19484 "\n"
19485 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19486 " npts - 1 elements), each containing either true to use the reversed\n"
19487 " HLS interpolation or false to use the regular HLS interpolation.\n"
19488 " (alt_hue_path[i] refers to the interpolation interval between the\n"
19489 " i and i + 1 control points). This parameter is not used for RGB\n"
19490 " colors (\n"
19491 " itype = true).\n"
19492 "\n"
19493 ""},
19494 { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, "\n"
19495 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19496 "\n"
19497 "DESCRIPTION:\n"
19498 "\n"
19499 " This is a variant of plscmap1l that supports alpha channel\n"
19500 " transparency. It sets cmap1 colors using a piece-wise linear\n"
19501 " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19502 " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19503 " transparency value (0.0-1.0). It may be called at any time.\n"
19504 "\n"
19505 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19506 " alpha, alt_hue_path)\n"
19507 "\n"
19508 " This function is used in example 30.\n"
19509 "\n"
19510 "\n"
19511 "\n"
19512 "SYNOPSIS:\n"
19513 "\n"
19514 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19515 "\n"
19516 "ARGUMENTS:\n"
19517 "\n"
19518 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19519 "\n"
19520 " npts (PLINT, input) : number of control points.\n"
19521 "\n"
19522 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19523 " intensity index (0.0-1.0) in ascending order for each control\n"
19524 " point.\n"
19525 "\n"
19526 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19527 " coordinate (H or R) for each control point.\n"
19528 "\n"
19529 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19530 " coordinate (L or G) for each control point.\n"
19531 "\n"
19532 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19533 " coordinate (S or B) for each control point.\n"
19534 "\n"
19535 " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19536 " transparency value (0.0-1.0) for each control point.\n"
19537 "\n"
19538 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19539 " npts - 1 elements) containing the alternative interpolation method\n"
19540 " Boolean value for each control point interval. (alt_hue_path[i]\n"
19541 " refers to the interpolation interval between the i and i + 1\n"
19542 " control points).\n"
19543 "\n"
19544 ""},
19545 { "plscmap1n", _wrap_plscmap1n, METH_O, "\n"
19546 "Set number of colors in cmap1\n"
19547 "\n"
19548 "DESCRIPTION:\n"
19549 "\n"
19550 " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19551 " values if this is the first allocation (see the PLplot documentation).\n"
19552 "\n"
19553 " Redacted form: plscmap1n(ncol1)\n"
19554 "\n"
19555 " This function is used in examples 8, 11, 20, and 21.\n"
19556 "\n"
19557 "\n"
19558 "\n"
19559 "SYNOPSIS:\n"
19560 "\n"
19561 "plscmap1n(ncol1)\n"
19562 "\n"
19563 "ARGUMENTS:\n"
19564 "\n"
19565 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19566 " the cmap1 palette. If this number is zero or less, then the value\n"
19567 " from the previous call to plscmap1n is used and if there is no\n"
19568 " previous call, then a default value is used.\n"
19569 "\n"
19570 ""},
19571 { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, "\n"
19572 "Set the cmap1 argument range for continuous color plots\n"
19573 "\n"
19574 "DESCRIPTION:\n"
19575 "\n"
19576 " Set the cmap1 argument range for continuous color plots that\n"
19577 " corresponds to the range of data values. The maximum range\n"
19578 " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
19579 " the cmap1 argument range that is specified with this routine, the\n"
19580 " smaller the subset of the cmap1 color palette that is used to\n"
19581 " represent the continuous data being plotted. If\n"
19582 " min_color is greater than\n"
19583 " max_color or\n"
19584 " max_color is greater than 1.0 or\n"
19585 " min_color is less than 0.0 then no change is made to the cmap1\n"
19586 " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
19587 "\n"
19588 " Redacted form: plscmap1_range(min_color, max_color)\n"
19589 "\n"
19590 " This function is currently used in example 33.\n"
19591 "\n"
19592 "\n"
19593 "\n"
19594 "SYNOPSIS:\n"
19595 "\n"
19596 "plscmap1_range(min_color, max_color)\n"
19597 "\n"
19598 "ARGUMENTS:\n"
19599 "\n"
19600 " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
19601 " than 0.0, then 0.0 is used instead.\n"
19602 "\n"
19603 " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
19604 " than 1.0, then 1.0 is used instead.\n"
19605 "\n"
19606 ""},
19607 { "plgcmap1_range", _wrap_plgcmap1_range, METH_NOARGS, "\n"
19608 "Get the cmap1 argument range for continuous color plots\n"
19609 "\n"
19610 "DESCRIPTION:\n"
19611 "\n"
19612 " Get the cmap1 argument range for continuous color plots. (Use\n"
19613 " plscmap1_range to set the cmap1 argument range.)\n"
19614 "\n"
19615 " Redacted form: plgcmap1_range(min_color, max_color)\n"
19616 "\n"
19617 " This function is currently not used in any example.\n"
19618 "\n"
19619 "\n"
19620 "\n"
19621 "SYNOPSIS:\n"
19622 "\n"
19623 "plgcmap1_range(min_color, max_color)\n"
19624 "\n"
19625 "ARGUMENTS:\n"
19626 "\n"
19627 " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19628 " minimum cmap1 argument.\n"
19629 "\n"
19630 " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
19631 " maximum cmap1 argument.\n"
19632 "\n"
19633 ""},
19634 { "plscol0", _wrap_plscol0, METH_VARARGS, "\n"
19635 "Set 8-bit RGB values for given cmap0 color index\n"
19636 "\n"
19637 "DESCRIPTION:\n"
19638 "\n"
19639 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
19640 " index. Overwrites the previous color value for the given index and,\n"
19641 " thus, does not result in any additional allocation of space for\n"
19642 " colors.\n"
19643 "\n"
19644 " Redacted form: plscol0(icol0, r, g, b)\n"
19645 "\n"
19646 " This function is used in any example 31.\n"
19647 "\n"
19648 "\n"
19649 "\n"
19650 "SYNOPSIS:\n"
19651 "\n"
19652 "plscol0(icol0, r, g, b)\n"
19653 "\n"
19654 "ARGUMENTS:\n"
19655 "\n"
19656 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19657 " number of colors (which is set by default, by plscmap0n, or even\n"
19658 " by plscmap0).\n"
19659 "\n"
19660 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19661 " degree of red in the color.\n"
19662 "\n"
19663 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19664 " degree of green in the color.\n"
19665 "\n"
19666 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19667 " degree of blue in the color.\n"
19668 "\n"
19669 ""},
19670 { "plscol0a", _wrap_plscol0a, METH_VARARGS, "\n"
19671 "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
19672 "\n"
19673 "DESCRIPTION:\n"
19674 "\n"
19675 " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
19676 " (see the PLplot documentation) index. Overwrites the previous color\n"
19677 " value for the given index and, thus, does not result in any additional\n"
19678 " allocation of space for colors.\n"
19679 "\n"
19680 " This function is used in example 30.\n"
19681 "\n"
19682 "\n"
19683 "\n"
19684 "SYNOPSIS:\n"
19685 "\n"
19686 "plscol0a(icol0, r, g, b, alpha)\n"
19687 "\n"
19688 "ARGUMENTS:\n"
19689 "\n"
19690 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
19691 " number of colors (which is set by default, by plscmap0n, or even\n"
19692 " by plscmap0).\n"
19693 "\n"
19694 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19695 " degree of red in the color.\n"
19696 "\n"
19697 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19698 " degree of green in the color.\n"
19699 "\n"
19700 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19701 " degree of blue in the color.\n"
19702 "\n"
19703 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
19704 " (0.0-1.0).\n"
19705 "\n"
19706 ""},
19707 { "plscolbg", _wrap_plscolbg, METH_VARARGS, "\n"
19708 "Set the background color by 8-bit RGB value\n"
19709 "\n"
19710 "DESCRIPTION:\n"
19711 "\n"
19712 " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
19713 " the PLplot documentation).\n"
19714 "\n"
19715 " Redacted form: plscolbg(r, g, b)\n"
19716 "\n"
19717 " This function is used in examples 15 and 31.\n"
19718 "\n"
19719 "\n"
19720 "\n"
19721 "SYNOPSIS:\n"
19722 "\n"
19723 "plscolbg(r, g, b)\n"
19724 "\n"
19725 "ARGUMENTS:\n"
19726 "\n"
19727 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19728 " degree of red in the color.\n"
19729 "\n"
19730 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19731 " degree of green in the color.\n"
19732 "\n"
19733 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19734 " degree of blue in the color.\n"
19735 "\n"
19736 ""},
19737 { "plscolbga", _wrap_plscolbga, METH_VARARGS, "\n"
19738 "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
19739 "\n"
19740 "DESCRIPTION:\n"
19741 "\n"
19742 " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
19743 " PLFLT alpha transparency value (see the PLplot documentation).\n"
19744 "\n"
19745 " This function is used in example 31.\n"
19746 "\n"
19747 "\n"
19748 "\n"
19749 "SYNOPSIS:\n"
19750 "\n"
19751 "plscolbga(r, g, b, alpha)\n"
19752 "\n"
19753 "ARGUMENTS:\n"
19754 "\n"
19755 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19756 " degree of red in the color.\n"
19757 "\n"
19758 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19759 " degree of green in the color.\n"
19760 "\n"
19761 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
19762 " degree of blue in the color.\n"
19763 "\n"
19764 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
19765 " (0.0-1.0).\n"
19766 "\n"
19767 ""},
19768 { "plscolor", _wrap_plscolor, METH_O, "\n"
19769 "Used to globally turn color output on/off\n"
19770 "\n"
19771 "DESCRIPTION:\n"
19772 "\n"
19773 " Used to globally turn color output on/off for those drivers/devices\n"
19774 " that support it.\n"
19775 "\n"
19776 " Redacted form: plscolor(color)\n"
19777 "\n"
19778 " This function is used in example 31.\n"
19779 "\n"
19780 "\n"
19781 "\n"
19782 "SYNOPSIS:\n"
19783 "\n"
19784 "plscolor(color)\n"
19785 "\n"
19786 "ARGUMENTS:\n"
19787 "\n"
19788 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
19789 " turned off. If non-zero, color is turned on.\n"
19790 "\n"
19791 ""},
19792 { "plscompression", _wrap_plscompression, METH_O, "\n"
19793 "Set device-compression level\n"
19794 "\n"
19795 "DESCRIPTION:\n"
19796 "\n"
19797 " Set device-compression level. Only used for drivers that provide\n"
19798 " compression. This function, if used, should be invoked before a call\n"
19799 " to plinit.\n"
19800 "\n"
19801 " Redacted form: plscompression(compression)\n"
19802 "\n"
19803 " This function is used in example 31.\n"
19804 "\n"
19805 "\n"
19806 "\n"
19807 "SYNOPSIS:\n"
19808 "\n"
19809 "plscompression(compression)\n"
19810 "\n"
19811 "ARGUMENTS:\n"
19812 "\n"
19813 " compression (PLINT, input) : The desired compression level. This is\n"
19814 " a device-dependent value. Currently only the jpeg and png devices\n"
19815 " use these values. For jpeg value is the jpeg quality which should\n"
19816 " normally be in the range 0-95. Higher values denote higher quality\n"
19817 " and hence larger image sizes. For png values are in the range -1\n"
19818 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
19819 " A value of -1 denotes the default zlib compression level. Values\n"
19820 " in the range 10-99 are divided by 10 and then used as the zlib\n"
19821 " compression level. Higher compression levels correspond to greater\n"
19822 " compression and small file sizes at the expense of more\n"
19823 " computation.\n"
19824 "\n"
19825 ""},
19826 { "plsdev", _wrap_plsdev, METH_O, "\n"
19827 "Set the device (keyword) name\n"
19828 "\n"
19829 "DESCRIPTION:\n"
19830 "\n"
19831 " Set the device (keyword) name.\n"
19832 "\n"
19833 " Redacted form: plsdev(devname)\n"
19834 "\n"
19835 " This function is used in examples 1, 14, and 20.\n"
19836 "\n"
19837 "\n"
19838 "\n"
19839 "SYNOPSIS:\n"
19840 "\n"
19841 "plsdev(devname)\n"
19842 "\n"
19843 "ARGUMENTS:\n"
19844 "\n"
19845 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
19846 " containing the device name keyword of the required output device.\n"
19847 " If\n"
19848 " devname is NULL or if the first character of the string is a ``?'',\n"
19849 " the normal (prompted) start up is used.\n"
19850 "\n"
19851 ""},
19852 { "plsdidev", _wrap_plsdidev, METH_VARARGS, "\n"
19853 "Set parameters that define current device-space window\n"
19854 "\n"
19855 "DESCRIPTION:\n"
19856 "\n"
19857 " Set relative margin width, aspect ratio, and relative justification\n"
19858 " that define current device-space window. If you want to just use the\n"
19859 " previous value for any of these, just pass in the magic value\n"
19860 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
19861 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
19862 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
19863 " to a device-specific value.\n"
19864 "\n"
19865 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
19866 "\n"
19867 " This function is used in example 31.\n"
19868 "\n"
19869 "\n"
19870 "\n"
19871 "SYNOPSIS:\n"
19872 "\n"
19873 "plsdidev(mar, aspect, jx, jy)\n"
19874 "\n"
19875 "ARGUMENTS:\n"
19876 "\n"
19877 " mar (PLFLT, input) : Relative margin width.\n"
19878 "\n"
19879 " aspect (PLFLT, input) : Aspect ratio.\n"
19880 "\n"
19881 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
19882 " the range -0.5 to 0.5.\n"
19883 "\n"
19884 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
19885 " the range -0.5 to 0.5.\n"
19886 "\n"
19887 ""},
19888 { "plsdimap", _wrap_plsdimap, METH_VARARGS, "\n"
19889 "Set up transformation from metafile coordinates\n"
19890 "\n"
19891 "DESCRIPTION:\n"
19892 "\n"
19893 " Set up transformation from metafile coordinates. The size of the plot\n"
19894 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
19895 " general-purpose facility just yet (not sure why the user would need\n"
19896 " it, for one).\n"
19897 "\n"
19898 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
19899 " dimypmm)\n"
19900 "\n"
19901 " This function is not used in any examples.\n"
19902 "\n"
19903 "\n"
19904 "\n"
19905 "SYNOPSIS:\n"
19906 "\n"
19907 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
19908 "\n"
19909 "ARGUMENTS:\n"
19910 "\n"
19911 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
19912 "\n"
19913 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
19914 "\n"
19915 " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
19916 "\n"
19917 " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
19918 "\n"
19919 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
19920 "\n"
19921 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
19922 "\n"
19923 ""},
19924 { "plsdiori", _wrap_plsdiori, METH_O, "\n"
19925 "Set plot orientation\n"
19926 "\n"
19927 "DESCRIPTION:\n"
19928 "\n"
19929 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
19930 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
19931 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
19932 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
19933 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
19934 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
19935 " not called the default value of rot is 0.\n"
19936 "\n"
19937 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
19938 " probably want to change the aspect ratio to a value suitable for the\n"
19939 " plot orientation using a call to plsdidev or the command-line options\n"
19940 " -a or -freeaspect. For more documentation of those options see the\n"
19941 " PLplot documentation. Such command-line options can be set internally\n"
19942 " using plsetopt or set directly using the command line and parsed using\n"
19943 " a call to plparseopts.\n"
19944 "\n"
19945 " Redacted form: plsdiori(rot)\n"
19946 "\n"
19947 " This function is not used in any examples.\n"
19948 "\n"
19949 "\n"
19950 "\n"
19951 "SYNOPSIS:\n"
19952 "\n"
19953 "plsdiori(rot)\n"
19954 "\n"
19955 "ARGUMENTS:\n"
19956 "\n"
19957 " rot (PLFLT, input) : Plot orientation parameter.\n"
19958 "\n"
19959 ""},
19960 { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, "\n"
19961 "Set parameters that define current plot-space window\n"
19962 "\n"
19963 "DESCRIPTION:\n"
19964 "\n"
19965 " Set relative minima and maxima that define the current plot-space\n"
19966 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
19967 " xmax, and ymax are 0., 0., 1., and 1.\n"
19968 "\n"
19969 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
19970 "\n"
19971 " This function is used in example 31.\n"
19972 "\n"
19973 "\n"
19974 "\n"
19975 "SYNOPSIS:\n"
19976 "\n"
19977 "plsdiplt(xmin, ymin, xmax, ymax)\n"
19978 "\n"
19979 "ARGUMENTS:\n"
19980 "\n"
19981 " xmin (PLFLT, input) : Relative minimum in x.\n"
19982 "\n"
19983 " ymin (PLFLT, input) : Relative minimum in y.\n"
19984 "\n"
19985 " xmax (PLFLT, input) : Relative maximum in x.\n"
19986 "\n"
19987 " ymax (PLFLT, input) : Relative maximum in y.\n"
19988 "\n"
19989 ""},
19990 { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, "\n"
19991 "Set parameters incrementally (zoom mode) that define current plot-space window\n"
19992 "\n"
19993 "DESCRIPTION:\n"
19994 "\n"
19995 " Set relative minima and maxima incrementally (zoom mode) that define\n"
19996 " the current plot-space window. This function has the same effect as\n"
19997 " plsdiplt if that function has not been previously called. Otherwise,\n"
19998 " this function implements zoom mode using the transformation min_used =\n"
19999 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20000 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20001 " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20002 "\n"
20003 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20004 "\n"
20005 " This function is used in example 31.\n"
20006 "\n"
20007 "\n"
20008 "\n"
20009 "SYNOPSIS:\n"
20010 "\n"
20011 "plsdiplz(xmin, ymin, xmax, ymax)\n"
20012 "\n"
20013 "ARGUMENTS:\n"
20014 "\n"
20015 " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20016 "\n"
20017 " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20018 "\n"
20019 " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20020 "\n"
20021 " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20022 "\n"
20023 ""},
20024 { "plseed", _wrap_plseed, METH_O, "\n"
20025 "Set seed for internal random number generator.\n"
20026 "\n"
20027 "DESCRIPTION:\n"
20028 "\n"
20029 " Set the seed for the internal random number generator. See plrandd for\n"
20030 " further details.\n"
20031 "\n"
20032 " Redacted form: plseed(seed)\n"
20033 "\n"
20034 " This function is used in example 21.\n"
20035 "\n"
20036 "\n"
20037 "\n"
20038 "SYNOPSIS:\n"
20039 "\n"
20040 "plseed(seed)\n"
20041 "\n"
20042 "ARGUMENTS:\n"
20043 "\n"
20044 " seed (unsigned int, input) : Seed for random number generator.\n"
20045 "\n"
20046 ""},
20047 { "plsesc", _wrap_plsesc, METH_O, "\n"
20048 "Set the escape character for text strings\n"
20049 "\n"
20050 "DESCRIPTION:\n"
20051 "\n"
20052 " Set the escape character for text strings. From C (in contrast to\n"
20053 " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
20054 " characters are allowed to prevent the user from shooting himself in\n"
20055 " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
20056 " use of backslash as a character escape). Here are the allowed escape\n"
20057 " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
20058 " #, ASCII 35\n"
20059 " $, ASCII 36\n"
20060 " %, ASCII 37\n"
20061 " &, ASCII 38\n"
20062 " *, ASCII 42\n"
20063 " @, ASCII 64\n"
20064 " ^, ASCII 94\n"
20065 " ~, ASCII 126\n"
20066 "\n"
20067 "\n"
20068 " Redacted form: General: plsesc(esc)\n"
20069 "\n"
20070 "\n"
20071 " This function is used in example 29.\n"
20072 "\n"
20073 "\n"
20074 "\n"
20075 "SYNOPSIS:\n"
20076 "\n"
20077 "plsesc(esc)\n"
20078 "\n"
20079 "ARGUMENTS:\n"
20080 "\n"
20081 " esc (char, input) : Escape character.\n"
20082 "\n"
20083 ""},
20084 { "plsetopt", _wrap_plsetopt, METH_VARARGS, "\n"
20085 "Set any command-line option\n"
20086 "\n"
20087 "DESCRIPTION:\n"
20088 "\n"
20089 " Set any command-line option internally from a program before it\n"
20090 " invokes plinit. opt is the name of the command-line option and optarg\n"
20091 " is the corresponding command-line option argument.\n"
20092 "\n"
20093 " This function returns 0 on success.\n"
20094 "\n"
20095 " Redacted form: plsetopt(opt, optarg)\n"
20096 "\n"
20097 " This function is used in example 14.\n"
20098 "\n"
20099 "\n"
20100 "\n"
20101 "SYNOPSIS:\n"
20102 "\n"
20103 "PLINT plsetopt(opt, optarg)\n"
20104 "\n"
20105 "ARGUMENTS:\n"
20106 "\n"
20107 " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20108 " the command-line option.\n"
20109 "\n"
20110 " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20111 " containing the argument of the command-line option.\n"
20112 "\n"
20113 ""},
20114 { "plsfam", _wrap_plsfam, METH_VARARGS, "\n"
20115 "Set family file parameters\n"
20116 "\n"
20117 "DESCRIPTION:\n"
20118 "\n"
20119 " Sets variables dealing with output file familying. Does nothing if\n"
20120 " familying not supported by the driver. This routine, if used, must be\n"
20121 " called before initializing PLplot. See the PLplot documentation for\n"
20122 " more information.\n"
20123 "\n"
20124 " Redacted form: plsfam(fam, num, bmax)\n"
20125 "\n"
20126 " This function is used in examples 14 and 31.\n"
20127 "\n"
20128 "\n"
20129 "\n"
20130 "SYNOPSIS:\n"
20131 "\n"
20132 "plsfam(fam, num, bmax)\n"
20133 "\n"
20134 "ARGUMENTS:\n"
20135 "\n"
20136 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20137 " is enabled.\n"
20138 "\n"
20139 " num (PLINT, input) : Current family file number.\n"
20140 "\n"
20141 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20142 " file.\n"
20143 "\n"
20144 ""},
20145 { "plsfci", _wrap_plsfci, METH_O, "\n"
20146 "Set FCI (font characterization integer)\n"
20147 "\n"
20148 "DESCRIPTION:\n"
20149 "\n"
20150 " Sets font characteristics to be used at the start of the next string\n"
20151 " using the FCI approach. See the PLplot documentation for more\n"
20152 " information. Note, plsfont (which calls plsfci internally) provides a\n"
20153 " more user-friendly API for setting the font characterisitics.\n"
20154 "\n"
20155 " Redacted form: General: plsfci(fci)\n"
20156 "\n"
20157 "\n"
20158 " This function is used in example 23.\n"
20159 "\n"
20160 "\n"
20161 "\n"
20162 "SYNOPSIS:\n"
20163 "\n"
20164 "plsfci(fci)\n"
20165 "\n"
20166 "ARGUMENTS:\n"
20167 "\n"
20168 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20169 " of FCI.\n"
20170 "\n"
20171 ""},
20172 { "plsfnam", _wrap_plsfnam, METH_O, "\n"
20173 "Set output file name\n"
20174 "\n"
20175 "DESCRIPTION:\n"
20176 "\n"
20177 " Sets the current output file name, if applicable. If the file name\n"
20178 " has not been specified and is required by the driver, the user will be\n"
20179 " prompted for it. If using the X-windows output driver, this sets the\n"
20180 " display name. This routine, if used, must be called before\n"
20181 " initializing PLplot.\n"
20182 "\n"
20183 " Redacted form: plsfnam(fnam)\n"
20184 "\n"
20185 " This function is used in examples 1 and 20.\n"
20186 "\n"
20187 "\n"
20188 "\n"
20189 "SYNOPSIS:\n"
20190 "\n"
20191 "plsfnam(fnam)\n"
20192 "\n"
20193 "ARGUMENTS:\n"
20194 "\n"
20195 " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20196 " the file name.\n"
20197 "\n"
20198 ""},
20199 { "plsfont", _wrap_plsfont, METH_VARARGS, "\n"
20200 "Set family, style and weight of the current font\n"
20201 "\n"
20202 "DESCRIPTION:\n"
20203 "\n"
20204 " Sets the current font. See the PLplot documentation for more\n"
20205 " information on font selection.\n"
20206 "\n"
20207 " Redacted form: plsfont(family, style, weight)\n"
20208 "\n"
20209 " This function is used in example 23.\n"
20210 "\n"
20211 "\n"
20212 "\n"
20213 "SYNOPSIS:\n"
20214 "\n"
20215 "plsfont(family, style, weight)\n"
20216 "\n"
20217 "ARGUMENTS:\n"
20218 "\n"
20219 " family (PLINT, input) : Font family to select for the current font.\n"
20220 " The available values are given by the PL_FCI_* constants in\n"
20221 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20222 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20223 " signifies that the font family should not be altered.\n"
20224 "\n"
20225 " style (PLINT, input) : Font style to select for the current font.\n"
20226 " The available values are given by the PL_FCI_* constants in\n"
20227 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20228 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20229 " should not be altered.\n"
20230 "\n"
20231 " weight (PLINT, input) : Font weight to select for the current font.\n"
20232 " The available values are given by the PL_FCI_* constants in\n"
20233 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20234 " negative value signifies that the font weight should not be\n"
20235 " altered.\n"
20236 "\n"
20237 ""},
20238 { "plshades", _wrap_plshades, METH_VARARGS, "\n"
20239 "Shade regions on the basis of value\n"
20240 "\n"
20241 "DESCRIPTION:\n"
20242 "\n"
20243 " Shade regions on the basis of value. This is the high-level routine\n"
20244 " for making continuous color shaded plots with cmap1 while plshade\n"
20245 " should be used to plot individual shaded regions using either cmap0 or\n"
20246 " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20247 " our supported languages.\n"
20248 "\n"
20249 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20250 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20251 " pltr_data)\n"
20252 "\n"
20253 "\n"
20254 " This function is used in examples 16, 21, and 22.\n"
20255 "\n"
20256 "\n"
20257 "\n"
20258 "SYNOPSIS:\n"
20259 "\n"
20260 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20261 "\n"
20262 "ARGUMENTS:\n"
20263 "\n"
20264 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20265 " plot. Should have dimensions of\n"
20266 " nx by\n"
20267 " ny.\n"
20268 "\n"
20269 " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20270 "\n"
20271 " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20272 "\n"
20273 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20274 " the region that should be plotted in the shade plot. This\n"
20275 " function accepts x and y coordinates as input arguments and must\n"
20276 " return 1 if the point is to be included in the shade plot and 0\n"
20277 " otherwise. If you want to plot the entire shade plot (the usual\n"
20278 " case), this argument should be set to NULL.\n"
20279 "\n"
20280 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20281 " pltr below for how these arguments are used (only for the special case\n"
20282 " when the callback function\n"
20283 " pltr is not supplied).\n"
20284 "\n"
20285 " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20286 " corresponding to the edges of each shaded region that will be\n"
20287 " plotted by this function. To work properly the levels should be\n"
20288 " monotonic.\n"
20289 "\n"
20290 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20291 " of shade edge values in clevel).\n"
20292 "\n"
20293 " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20294 " pattern.\n"
20295 "\n"
20296 " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20297 " contours defining edges of shaded regions. The pen color is only\n"
20298 " temporary set for the contour drawing. Set this value to zero or\n"
20299 " less if no shade edge contours are wanted.\n"
20300 "\n"
20301 " cont_width (PLFLT, input) : Defines line width used for contours\n"
20302 " defining edges of shaded regions. This value may not be honored\n"
20303 " by all drivers. The pen width is only temporary set for the\n"
20304 " contour drawing. Set this value to zero or less if no shade edge\n"
20305 " contours are wanted.\n"
20306 "\n"
20307 " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20308 " region. Use plfill for this purpose.\n"
20309 "\n"
20310 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20311 " map to rectangles after coordinate transformation with pltrl.\n"
20312 " Otherwise, set rectangular to false. If rectangular is set to\n"
20313 " true, plshade tries to save time by filling large rectangles.\n"
20314 " This optimization fails if the coordinate transformation distorts\n"
20315 " the shape of rectangles. For example a plot in polar coordinates\n"
20316 " has to have rectangular set to false.\n"
20317 "\n"
20318 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20319 " defines the transformation between the zero-based indices of the\n"
20320 " matrix a and world coordinates. If\n"
20321 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20322 " indices of a are mapped to the range\n"
20323 " xmin through\n"
20324 " xmax and the y indices of a are mapped to the range\n"
20325 " ymin through\n"
20326 " ymax.For the C case, transformation functions are provided in the\n"
20327 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20328 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20329 " matrices. In addition, C callback routines for the transformation\n"
20330 " can be supplied by the user such as the mypltr function in\n"
20331 " examples/c/x09c.c which provides a general linear transformation\n"
20332 " between index coordinates and world coordinates.For languages\n"
20333 " other than C you should consult the PLplot documentation for the\n"
20334 " details concerning how PLTRANSFORM_callback arguments are\n"
20335 " interfaced. However, in general, a particular pattern of\n"
20336 " callback-associated arguments such as a tr vector with 6 elements;\n"
20337 " xg and yg vectors; or xg and yg matrices are respectively\n"
20338 " interfaced to a linear-transformation routine similar to the above\n"
20339 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20340 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20341 " support native language callbacks for handling index to\n"
20342 " world-coordinate transformations. Examples of these various\n"
20343 " approaches are given in examples/<language>x09*,\n"
20344 " examples/<language>x16*, examples/<language>x20*,\n"
20345 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20346 " supported languages.\n"
20347 "\n"
20348 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20349 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20350 " externally supplied.\n"
20351 "\n"
20352 ""},
20353 { "plshade", _wrap_plshade, METH_VARARGS, "\n"
20354 "Shade individual region on the basis of value\n"
20355 "\n"
20356 "DESCRIPTION:\n"
20357 "\n"
20358 " Shade individual region on the basis of value. Use plshades if you\n"
20359 " want to shade a number of contiguous regions using continuous colors.\n"
20360 " In particular the edge contours are treated properly in plshades. If\n"
20361 " you attempt to do contiguous regions with plshade the contours at the\n"
20362 " edge of the shade are partially obliterated by subsequent plots of\n"
20363 " contiguous shaded regions.\n"
20364 "\n"
20365 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20366 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20367 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20368 "\n"
20369 "\n"
20370 " This function is used in example 15.\n"
20371 "\n"
20372 "\n"
20373 "\n"
20374 "SYNOPSIS:\n"
20375 "\n"
20376 "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"
20377 "\n"
20378 "ARGUMENTS:\n"
20379 "\n"
20380 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20381 " plot. Should have dimensions of\n"
20382 " nx by\n"
20383 " ny.\n"
20384 "\n"
20385 " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20386 "\n"
20387 " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20388 "\n"
20389 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20390 " the region that should be plotted in the shade plot. This\n"
20391 " function accepts x and y coordinates as input arguments and must\n"
20392 " return 1 if the point is to be included in the shade plot and 0\n"
20393 " otherwise. If you want to plot the entire shade plot (the usual\n"
20394 " case), this argument should be set to NULL.\n"
20395 "\n"
20396 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20397 " pltr below for how these arguments are used (only for the special case\n"
20398 " when the callback function\n"
20399 " pltr is not supplied).\n"
20400 "\n"
20401 " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20402 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20403 "\n"
20404 " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20405 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20406 "\n"
20407 " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20408 " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20409 " then sh_color is interpreted as a cmap1 argument in the range\n"
20410 " (0.0-1.0).\n"
20411 "\n"
20412 " sh_color (PLFLT, input) : Defines color map index with integer\n"
20413 " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20414 "\n"
20415 " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20416 "\n"
20417 " min_color (PLINT, input) : Defines pen color, width used by the\n"
20418 " boundary of shaded region. The min values are used for the\n"
20419 " shade_min boundary, and the max values are used on the shade_max\n"
20420 " boundary. Set color and width to zero for no plotted boundaries.\n"
20421 "\n"
20422 " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20423 " boundary of shaded region. The min values are used for the\n"
20424 " shade_min boundary, and the max values are used on the shade_max\n"
20425 " boundary. Set color and width to zero for no plotted boundaries.\n"
20426 "\n"
20427 " max_color (PLINT, input) : Defines pen color, width used by the\n"
20428 " boundary of shaded region. The min values are used for the\n"
20429 " shade_min boundary, and the max values are used on the shade_max\n"
20430 " boundary. Set color and width to zero for no plotted boundaries.\n"
20431 "\n"
20432 " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20433 " boundary of shaded region. The min values are used for the\n"
20434 " shade_min boundary, and the max values are used on the shade_max\n"
20435 " boundary. Set color and width to zero for no plotted boundaries.\n"
20436 "\n"
20437 " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20438 " Use plfill. Future version of PLplot may have other fill\n"
20439 " routines.\n"
20440 "\n"
20441 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20442 " map to rectangles after coordinate transformation with pltrl.\n"
20443 " Otherwise, set rectangular to false. If rectangular is set to\n"
20444 " true, plshade tries to save time by filling large rectangles.\n"
20445 " This optimization fails if the coordinate transformation distorts\n"
20446 " the shape of rectangles. For example a plot in polar coordinates\n"
20447 " has to have rectangular set to false.\n"
20448 "\n"
20449 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20450 " defines the transformation between the zero-based indices of the\n"
20451 " matrix a and world coordinates. If\n"
20452 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20453 " indices of a are mapped to the range\n"
20454 " xmin through\n"
20455 " xmax and the y indices of a are mapped to the range\n"
20456 " ymin through\n"
20457 " ymax.For the C case, transformation functions are provided in the\n"
20458 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20459 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20460 " matrices. In addition, C callback routines for the transformation\n"
20461 " can be supplied by the user such as the mypltr function in\n"
20462 " examples/c/x09c.c which provides a general linear transformation\n"
20463 " between index coordinates and world coordinates.For languages\n"
20464 " other than C you should consult the PLplot documentation for the\n"
20465 " details concerning how PLTRANSFORM_callback arguments are\n"
20466 " interfaced. However, in general, a particular pattern of\n"
20467 " callback-associated arguments such as a tr vector with 6 elements;\n"
20468 " xg and yg vectors; or xg and yg matrices are respectively\n"
20469 " interfaced to a linear-transformation routine similar to the above\n"
20470 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20471 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20472 " support native language callbacks for handling index to\n"
20473 " world-coordinate transformations. Examples of these various\n"
20474 " approaches are given in examples/<language>x09*,\n"
20475 " examples/<language>x16*, examples/<language>x20*,\n"
20476 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20477 " supported languages.\n"
20478 "\n"
20479 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20480 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20481 " externally supplied.\n"
20482 "\n"
20483 ""},
20484 { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, "\n"
20485 "Assign a function to use for generating custom axis labels\n"
20486 "\n"
20487 "DESCRIPTION:\n"
20488 "\n"
20489 " This function allows a user to provide their own function to provide\n"
20490 " axis label text. The user function is given the numeric value for a\n"
20491 " point on an axis and returns a string label to correspond with that\n"
20492 " value. Custom axis labels can be enabled by passing appropriate\n"
20493 " arguments to plenv, plbox, plbox3 and similar functions.\n"
20494 "\n"
20495 " This function is used in example 19.\n"
20496 "\n"
20497 "\n"
20498 "\n"
20499 "SYNOPSIS:\n"
20500 "\n"
20501 "plslabelfunc(label_func, label_data)\n"
20502 "\n"
20503 "ARGUMENTS:\n"
20504 "\n"
20505 " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20506 " label function. In order to reset to the default labelling, set\n"
20507 " this to NULL. The labelling function parameters are, in order:\n"
20508 " axis: This indicates which axis a label is being requested for.\n"
20509 " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20510 "\n"
20511 " value: This is the value along the axis which is being labelled.\n"
20512 "\n"
20513 " label_text: The string representation of the label value.\n"
20514 "\n"
20515 " length: The maximum length in characters allowed for label_text.\n"
20516 "\n"
20517 "\n"
20518 " label_data (PLPointer, input) : This parameter may be used to pass\n"
20519 " data to the label_func function.\n"
20520 "\n"
20521 ""},
20522 { "plsmaj", _wrap_plsmaj, METH_VARARGS, "\n"
20523 "Set length of major ticks\n"
20524 "\n"
20525 "DESCRIPTION:\n"
20526 "\n"
20527 " This sets up the length of the major ticks. The actual length is the\n"
20528 " product of the default length and a scaling factor as for character\n"
20529 " height.\n"
20530 "\n"
20531 " Redacted form: plsmaj(def, scale)\n"
20532 "\n"
20533 " This function is used in example 29.\n"
20534 "\n"
20535 "\n"
20536 "\n"
20537 "SYNOPSIS:\n"
20538 "\n"
20539 "plsmaj(def, scale)\n"
20540 "\n"
20541 "ARGUMENTS:\n"
20542 "\n"
20543 " def (PLFLT, input) : The default length of a major tick in\n"
20544 " millimeters, should be set to zero if the default length is to\n"
20545 " remain unchanged.\n"
20546 "\n"
20547 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20548 " actual tick length.\n"
20549 "\n"
20550 ""},
20551 { "plsmem", _wrap_plsmem, METH_VARARGS, "\n"
20552 "Set the memory area to be plotted (RGB)\n"
20553 "\n"
20554 "DESCRIPTION:\n"
20555 "\n"
20556 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20557 " the dev member of the stream structure. Also set the number of pixels\n"
20558 " in the memory passed in\n"
20559 " plotmem, which is a block of memory\n"
20560 " maxy by\n"
20561 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
20562 "\n"
20563 " This memory will have to be freed by the user!\n"
20564 "\n"
20565 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20566 "\n"
20567 " This function is not used in any examples.\n"
20568 "\n"
20569 "\n"
20570 "\n"
20571 "SYNOPSIS:\n"
20572 "\n"
20573 "plsmem(maxx, maxy, plotmem)\n"
20574 "\n"
20575 "ARGUMENTS:\n"
20576 "\n"
20577 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20578 "\n"
20579 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20580 "\n"
20581 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
20582 " user-supplied writeable memory area.\n"
20583 "\n"
20584 ""},
20585 { "plsmema", _wrap_plsmema, METH_VARARGS, "\n"
20586 "Set the memory area to be plotted (RGBA)\n"
20587 "\n"
20588 "DESCRIPTION:\n"
20589 "\n"
20590 " Set the memory area to be plotted (with the memcairo driver) as the\n"
20591 " dev member of the stream structure. Also set the number of pixels in\n"
20592 " the memory passed in\n"
20593 " plotmem, which is a block of memory\n"
20594 " maxy by\n"
20595 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
20596 "\n"
20597 " This memory will have to be freed by the user!\n"
20598 "\n"
20599 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
20600 "\n"
20601 " This function is not used in any examples.\n"
20602 "\n"
20603 "\n"
20604 "\n"
20605 "SYNOPSIS:\n"
20606 "\n"
20607 "plsmema(maxx, maxy, plotmem)\n"
20608 "\n"
20609 "ARGUMENTS:\n"
20610 "\n"
20611 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20612 "\n"
20613 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20614 "\n"
20615 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
20616 " user-supplied writeable memory area.\n"
20617 "\n"
20618 ""},
20619 { "plsmin", _wrap_plsmin, METH_VARARGS, "\n"
20620 "Set length of minor ticks\n"
20621 "\n"
20622 "DESCRIPTION:\n"
20623 "\n"
20624 " This sets up the length of the minor ticks and the length of the\n"
20625 " terminals on error bars. The actual length is the product of the\n"
20626 " default length and a scaling factor as for character height.\n"
20627 "\n"
20628 " Redacted form: plsmin(def, scale)\n"
20629 "\n"
20630 " This function is used in example 29.\n"
20631 "\n"
20632 "\n"
20633 "\n"
20634 "SYNOPSIS:\n"
20635 "\n"
20636 "plsmin(def, scale)\n"
20637 "\n"
20638 "ARGUMENTS:\n"
20639 "\n"
20640 " def (PLFLT, input) : The default length of a minor tick in\n"
20641 " millimeters, should be set to zero if the default length is to\n"
20642 " remain unchanged.\n"
20643 "\n"
20644 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20645 " actual tick length.\n"
20646 "\n"
20647 ""},
20648 { "plsori", _wrap_plsori, METH_O, "\n"
20649 "Set orientation\n"
20650 "\n"
20651 "DESCRIPTION:\n"
20652 "\n"
20653 " Set integer plot orientation parameter. This function is identical to\n"
20654 " plsdiori except for the type of the argument, and should be used in\n"
20655 " the same way. See the documentation of plsdiori for details.\n"
20656 "\n"
20657 " Redacted form: plsori(ori)\n"
20658 "\n"
20659 " This function is used in example 3.\n"
20660 "\n"
20661 "\n"
20662 "\n"
20663 "SYNOPSIS:\n"
20664 "\n"
20665 "plsori(ori)\n"
20666 "\n"
20667 "ARGUMENTS:\n"
20668 "\n"
20669 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
20670 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
20671 " angle.\n"
20672 "\n"
20673 ""},
20674 { "plspage", _wrap_plspage, METH_VARARGS, "\n"
20675 "Set page parameters\n"
20676 "\n"
20677 "DESCRIPTION:\n"
20678 "\n"
20679 " Sets the page configuration (optional). If an individual parameter is\n"
20680 " zero then that parameter value is not updated. Not all parameters are\n"
20681 " recognized by all drivers and the interpretation is device-dependent.\n"
20682 " The X-window driver uses the length and offset parameters to determine\n"
20683 " the window size and location. The length and offset values are\n"
20684 " expressed in units that are specific to the current driver. For\n"
20685 " instance: screen drivers will usually interpret them as number of\n"
20686 " pixels, whereas printer drivers will usually use mm.\n"
20687 "\n"
20688 " This routine, if used, must be called before initializing PLplot. It\n"
20689 " may be called at later times for interactive drivers to change only\n"
20690 " the dpi for subsequent redraws which you can force via a call to\n"
20691 " plreplot. If this function is not called then the page size defaults\n"
20692 " to landscape A4 for drivers which use real world page sizes and 744\n"
20693 " pixels wide by 538 pixels high for raster drivers. The default value\n"
20694 " for dx and dy is 90 pixels per inch for raster drivers.\n"
20695 "\n"
20696 "\n"
20697 "\n"
20698 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20699 "\n"
20700 " This function is used in examples 14 and 31.\n"
20701 "\n"
20702 "\n"
20703 "\n"
20704 "SYNOPSIS:\n"
20705 "\n"
20706 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
20707 "\n"
20708 "ARGUMENTS:\n"
20709 "\n"
20710 " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
20711 " by raster drivers, ignored by drivers which use \"real world\" units\n"
20712 " (e.g. mm).\n"
20713 "\n"
20714 " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
20715 " by raster drivers, ignored by drivers which use \"real world\" units\n"
20716 " (e.g. mm).\n"
20717 "\n"
20718 " xleng (PLINT, input) : Page length, x.\n"
20719 "\n"
20720 " yleng (PLINT, input) : Page length, y.\n"
20721 "\n"
20722 " xoff (PLINT, input) : Page offset, x.\n"
20723 "\n"
20724 " yoff (PLINT, input) : Page offset, y.\n"
20725 "\n"
20726 ""},
20727 { "plspal0", _wrap_plspal0, METH_O, "\n"
20728 "Set the cmap0 palette using the specified cmap0*.pal format file\n"
20729 "\n"
20730 "DESCRIPTION:\n"
20731 "\n"
20732 " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
20733 "\n"
20734 " Redacted form: plspal0(filename)\n"
20735 "\n"
20736 " This function is in example 16.\n"
20737 "\n"
20738 "\n"
20739 "\n"
20740 "SYNOPSIS:\n"
20741 "\n"
20742 "plspal0(filename)\n"
20743 "\n"
20744 "ARGUMENTS:\n"
20745 "\n"
20746 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
20747 " containing the name of the cmap0*.pal file. If this string is\n"
20748 " empty, use the default cmap0*.pal file.\n"
20749 "\n"
20750 ""},
20751 { "plspal1", _wrap_plspal1, METH_VARARGS, "\n"
20752 "Set the cmap1 palette using the specified cmap1*.pal format file\n"
20753 "\n"
20754 "DESCRIPTION:\n"
20755 "\n"
20756 " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
20757 "\n"
20758 " Redacted form: plspal1(filename, interpolate)\n"
20759 "\n"
20760 " This function is used in example 16.\n"
20761 "\n"
20762 "\n"
20763 "\n"
20764 "SYNOPSIS:\n"
20765 "\n"
20766 "plspal1(filename, interpolate)\n"
20767 "\n"
20768 "ARGUMENTS:\n"
20769 "\n"
20770 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
20771 " containing the name of the cmap1*.pal file. If this string is\n"
20772 " empty, use the default cmap1*.pal file.\n"
20773 "\n"
20774 " interpolate (PLBOOL, input) : If this parameter is true, the\n"
20775 " columns containing the intensity index, r, g, b, alpha and\n"
20776 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
20777 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
20778 " a flag which controls whether the r, g, b data sent to plscmap1la\n"
20779 " are interpreted as HLS or RGB.) If this parameter is false, the\n"
20780 " intensity index and alt_hue_path columns are ignored and the r, g,\n"
20781 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
20782 " are used instead to set the cmap1 palette directly with a call to\n"
20783 " plscmap1a.\n"
20784 "\n"
20785 ""},
20786 { "plspause", _wrap_plspause, METH_O, "\n"
20787 "Set the pause (on end-of-page) status\n"
20788 "\n"
20789 "DESCRIPTION:\n"
20790 "\n"
20791 " Set the pause (on end-of-page) status.\n"
20792 "\n"
20793 " Redacted form: plspause(pause)\n"
20794 "\n"
20795 " This function is in examples 14,20.\n"
20796 "\n"
20797 "\n"
20798 "\n"
20799 "SYNOPSIS:\n"
20800 "\n"
20801 "plspause(pause)\n"
20802 "\n"
20803 "ARGUMENTS:\n"
20804 "\n"
20805 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
20806 " end-of-page for those drivers which support this. Otherwise there\n"
20807 " is no pause.\n"
20808 "\n"
20809 ""},
20810 { "plsstrm", _wrap_plsstrm, METH_O, "\n"
20811 "Set current output stream\n"
20812 "\n"
20813 "DESCRIPTION:\n"
20814 "\n"
20815 " Sets the number of the current output stream. The stream number\n"
20816 " defaults to 0 unless changed by this routine. The first use of this\n"
20817 " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
20818 "\n"
20819 " Redacted form: plsstrm(strm)\n"
20820 "\n"
20821 " This function is examples 1,14,20.\n"
20822 "\n"
20823 "\n"
20824 "\n"
20825 "SYNOPSIS:\n"
20826 "\n"
20827 "plsstrm(strm)\n"
20828 "\n"
20829 "ARGUMENTS:\n"
20830 "\n"
20831 " strm (PLINT, input) : The current stream number.\n"
20832 "\n"
20833 ""},
20834 { "plssub", _wrap_plssub, METH_VARARGS, "\n"
20835 "Set the number of subpages in x and y\n"
20836 "\n"
20837 "DESCRIPTION:\n"
20838 "\n"
20839 " Set the number of subpages in x and y.\n"
20840 "\n"
20841 " Redacted form: plssub(nx, ny)\n"
20842 "\n"
20843 " This function is examples 1,2,14,21,25,27.\n"
20844 "\n"
20845 "\n"
20846 "\n"
20847 "SYNOPSIS:\n"
20848 "\n"
20849 "plssub(nx, ny)\n"
20850 "\n"
20851 "ARGUMENTS:\n"
20852 "\n"
20853 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
20854 " of window columns).\n"
20855 "\n"
20856 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
20857 " of window rows).\n"
20858 "\n"
20859 ""},
20860 { "plssym", _wrap_plssym, METH_VARARGS, "\n"
20861 "Set symbol size\n"
20862 "\n"
20863 "DESCRIPTION:\n"
20864 "\n"
20865 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
20866 " plsym. The actual height of a symbol is the product of the default\n"
20867 " symbol size and a scaling factor as for the character height.\n"
20868 "\n"
20869 " Redacted form: plssym(def, scale)\n"
20870 "\n"
20871 " This function is used in example 29.\n"
20872 "\n"
20873 "\n"
20874 "\n"
20875 "SYNOPSIS:\n"
20876 "\n"
20877 "plssym(def, scale)\n"
20878 "\n"
20879 "ARGUMENTS:\n"
20880 "\n"
20881 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
20882 " should be set to zero if the default height is to remain\n"
20883 " unchanged.\n"
20884 "\n"
20885 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20886 " actual symbol height.\n"
20887 "\n"
20888 ""},
20889 { "plstar", _wrap_plstar, METH_VARARGS, "\n"
20890 "Initialization\n"
20891 "\n"
20892 "DESCRIPTION:\n"
20893 "\n"
20894 " Initializing the plotting package. The program prompts for the device\n"
20895 " keyword or number of the desired output device. Hitting a RETURN in\n"
20896 " response to the prompt is the same as selecting the first device. If\n"
20897 " only one device is enabled when PLplot is installed, plstar will issue\n"
20898 " no prompt. The output device is divided into nx by ny subpages, each\n"
20899 " of which may be used independently. The subroutine pladv is used to\n"
20900 " advance from one subpage to the next.\n"
20901 "\n"
20902 " Redacted form: plstar(nx, ny)\n"
20903 "\n"
20904 " This function is used in example 1.\n"
20905 "\n"
20906 "\n"
20907 "\n"
20908 "SYNOPSIS:\n"
20909 "\n"
20910 "plstar(nx, ny)\n"
20911 "\n"
20912 "ARGUMENTS:\n"
20913 "\n"
20914 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20915 " x direction.\n"
20916 "\n"
20917 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20918 " y direction.\n"
20919 "\n"
20920 ""},
20921 { "plstart", _wrap_plstart, METH_VARARGS, "\n"
20922 "Initialization\n"
20923 "\n"
20924 "DESCRIPTION:\n"
20925 "\n"
20926 " Alternative to plstar for initializing the plotting package. The\n"
20927 " device name keyword for the desired output device must be supplied as\n"
20928 " an argument. These keywords are the same as those printed out by\n"
20929 " plstar. If the requested device is not available, or if the input\n"
20930 " string is empty or begins with ``?'', the prompted start up of plstar\n"
20931 " is used. This routine also divides the output device page into nx by\n"
20932 " ny subpages, each of which may be used independently. The subroutine\n"
20933 " pladv is used to advance from one subpage to the next.\n"
20934 "\n"
20935 " Redacted form: General: plstart(devname, nx, ny)\n"
20936 "\n"
20937 "\n"
20938 " This function is not used in any examples.\n"
20939 "\n"
20940 "\n"
20941 "\n"
20942 "SYNOPSIS:\n"
20943 "\n"
20944 "plstart(devname, nx, ny)\n"
20945 "\n"
20946 "ARGUMENTS:\n"
20947 "\n"
20948 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20949 " containing the device name keyword of the required output device.\n"
20950 " If\n"
20951 " devname is NULL or if the first character of the string is a ``?'',\n"
20952 " the normal (prompted) start up is used.\n"
20953 "\n"
20954 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
20955 " x direction.\n"
20956 "\n"
20957 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
20958 " y direction.\n"
20959 "\n"
20960 ""},
20961 { "plstransform", _wrap_plstransform, METH_VARARGS, "\n"
20962 "Set a global coordinate transform function\n"
20963 "\n"
20964 "DESCRIPTION:\n"
20965 "\n"
20966 " This function can be used to define a coordinate transformation which\n"
20967 " affects all elements drawn within the current plot window. The\n"
20968 " coordinate_transform callback function is similar to that provided for\n"
20969 " the plmap and plmeridians functions. The coordinate_transform_data\n"
20970 " parameter may be used to pass extra data to coordinate_transform.\n"
20971 "\n"
20972 " Redacted form: General: plstransform(coordinate_transform,\n"
20973 " coordinate_transform_data)\n"
20974 "\n"
20975 "\n"
20976 " This function is used in examples 19 and 22.\n"
20977 "\n"
20978 "\n"
20979 "\n"
20980 "SYNOPSIS:\n"
20981 "\n"
20982 "plstransform(coordinate_transform, coordinate_transform_data)\n"
20983 "\n"
20984 "ARGUMENTS:\n"
20985 "\n"
20986 " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
20987 " function that defines the transformation from the input (x, y)\n"
20988 " world coordinates to new PLplot world coordinates. If\n"
20989 " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
20990 " case), then no transform is applied.\n"
20991 "\n"
20992 " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
20993 " for\n"
20994 " coordinate_transform.\n"
20995 "\n"
20996 ""},
20997 { "plstring", _wrap_plstring, METH_VARARGS, "\n"
20998 "Plot a glyph at the specified points\n"
20999 "\n"
21000 "DESCRIPTION:\n"
21001 "\n"
21002 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21003 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21004 " is specified with a PLplot user string. Note that the user string is\n"
21005 " not actually limited to one glyph so it is possible (but not normally\n"
21006 " useful) to plot more than one glyph at the specified points with this\n"
21007 " function. As with plmtex and plptex, the user string can contain FCI\n"
21008 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21009 " else PLplot escapes for Hershey or unicode text to determine the\n"
21010 " glyph.\n"
21011 "\n"
21012 " Redacted form: plstring(x, y, string)\n"
21013 "\n"
21014 " This function is used in examples 4, 21 and 26.\n"
21015 "\n"
21016 "\n"
21017 "\n"
21018 "SYNOPSIS:\n"
21019 "\n"
21020 "plstring(n, x, y, string)\n"
21021 "\n"
21022 "ARGUMENTS:\n"
21023 "\n"
21024 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21025 "\n"
21026 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21027 " the points.\n"
21028 "\n"
21029 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21030 " the points.\n"
21031 "\n"
21032 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21033 " the glyph(s) to be plotted at each of the n points.\n"
21034 "\n"
21035 ""},
21036 { "plstring3", _wrap_plstring3, METH_VARARGS, "\n"
21037 "Plot a glyph at the specified 3D points\n"
21038 "\n"
21039 "DESCRIPTION:\n"
21040 "\n"
21041 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21042 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21043 " this function similar to what is done for plline3. The glyph is\n"
21044 " specified with a PLplot user string. Note that the user string is not\n"
21045 " actually limited to one glyph so it is possible (but not normally\n"
21046 " useful) to plot more than one glyph at the specified points with this\n"
21047 " function. As with plmtex and plptex, the user string can contain FCI\n"
21048 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21049 " else PLplot escapes for Hershey or unicode text to determine the\n"
21050 " glyph.\n"
21051 "\n"
21052 " Redacted form: plstring3(x, y, z, string)\n"
21053 "\n"
21054 " This function is used in example 18.\n"
21055 "\n"
21056 "\n"
21057 "\n"
21058 "SYNOPSIS:\n"
21059 "\n"
21060 "plstring3(n, x, y, z, string)\n"
21061 "\n"
21062 "ARGUMENTS:\n"
21063 "\n"
21064 " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21065 "\n"
21066 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21067 " the points.\n"
21068 "\n"
21069 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21070 " the points.\n"
21071 "\n"
21072 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21073 " the points.\n"
21074 "\n"
21075 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21076 " the glyph(s) to be plotted at each of the n points. points.\n"
21077 "\n"
21078 ""},
21079 { "plstripa", _wrap_plstripa, METH_VARARGS, "\n"
21080 "Add a point to a strip chart\n"
21081 "\n"
21082 "DESCRIPTION:\n"
21083 "\n"
21084 " Add a point to a given pen of a given strip chart. There is no need\n"
21085 " for all pens to have the same number of points or to be equally\n"
21086 " sampled in the x coordinate. Allocates memory and rescales as\n"
21087 " necessary.\n"
21088 "\n"
21089 " Redacted form: plstripa(id, pen, x, y)\n"
21090 "\n"
21091 " This function is used in example 17.\n"
21092 "\n"
21093 "\n"
21094 "\n"
21095 "SYNOPSIS:\n"
21096 "\n"
21097 "plstripa(id, pen, x, y)\n"
21098 "\n"
21099 "ARGUMENTS:\n"
21100 "\n"
21101 " id (PLINT, input) : Identification number of the strip chart (set\n"
21102 " up in plstripc).\n"
21103 "\n"
21104 " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21105 "\n"
21106 " x (PLFLT, input) : X coordinate of point to plot.\n"
21107 "\n"
21108 " y (PLFLT, input) : Y coordinate of point to plot.\n"
21109 "\n"
21110 ""},
21111 { "plstripc", _wrap_plstripc, METH_VARARGS, "\n"
21112 "Create a 4-pen strip chart\n"
21113 "\n"
21114 "DESCRIPTION:\n"
21115 "\n"
21116 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21117 "\n"
21118 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21119 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21120 " styline, legline, labx, laby, labz)\n"
21121 "\n"
21122 "\n"
21123 " This function is used in example 17.\n"
21124 "\n"
21125 "\n"
21126 "\n"
21127 "SYNOPSIS:\n"
21128 "\n"
21129 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21130 "\n"
21131 "ARGUMENTS:\n"
21132 "\n"
21133 " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21134 " number of the strip chart to use on plstripa and plstripd.\n"
21135 "\n"
21136 " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21137 " the x-axis specification as in plbox.\n"
21138 "\n"
21139 " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21140 " the y-axis specification as in plbox.\n"
21141 "\n"
21142 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21143 " change as data are added.\n"
21144 "\n"
21145 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21146 " change as data are added.\n"
21147 "\n"
21148 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21149 " is multiplied by the factor (1 +\n"
21150 " xjump) .\n"
21151 "\n"
21152 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21153 " change as data are added.\n"
21154 "\n"
21155 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21156 " change as data are added.\n"
21157 "\n"
21158 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21159 "\n"
21160 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21161 "\n"
21162 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21163 " true, otherwise not.\n"
21164 "\n"
21165 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21166 " otherwise slide display.\n"
21167 "\n"
21168 " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21169 "\n"
21170 " collab (PLINT, input) : Legend color index (cmap0).\n"
21171 "\n"
21172 " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21173 " indices for the 4 pens.\n"
21174 "\n"
21175 " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21176 " indices for the 4 pens.\n"
21177 "\n"
21178 " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21179 " strings containing legends for the 4 pens.\n"
21180 "\n"
21181 " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21182 " the label for the x axis.\n"
21183 "\n"
21184 " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21185 " the label for the y axis.\n"
21186 "\n"
21187 " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21188 " the plot title.\n"
21189 "\n"
21190 ""},
21191 { "plstripd", _wrap_plstripd, METH_O, "\n"
21192 "Deletes and releases memory used by a strip chart\n"
21193 "\n"
21194 "DESCRIPTION:\n"
21195 "\n"
21196 " Deletes and releases memory used by a strip chart.\n"
21197 "\n"
21198 " Redacted form: plstripd(id)\n"
21199 "\n"
21200 " This function is used in example 17.\n"
21201 "\n"
21202 "\n"
21203 "\n"
21204 "SYNOPSIS:\n"
21205 "\n"
21206 "plstripd(id)\n"
21207 "\n"
21208 "ARGUMENTS:\n"
21209 "\n"
21210 " id (PLINT, input) : Identification number of strip chart to delete.\n"
21211 "\n"
21212 ""},
21213 { "plstyl", _wrap_plstyl, METH_VARARGS, "\n"
21214 "Set line style\n"
21215 "\n"
21216 "DESCRIPTION:\n"
21217 "\n"
21218 " This sets up the line style for all lines subsequently drawn. A line\n"
21219 " consists of segments in which the pen is alternately down and up. The\n"
21220 " lengths of these segments are passed in the vectors mark and space\n"
21221 " respectively. The number of mark-space pairs is specified by nms. In\n"
21222 " order to return the line style to the default continuous line, plstyl\n"
21223 " should be called with nms =0 .(see also pllsty)\n"
21224 "\n"
21225 " Redacted form: plstyl(mark, space)\n"
21226 "\n"
21227 " This function is used in examples 1, 9, and 14.\n"
21228 "\n"
21229 "\n"
21230 "\n"
21231 "SYNOPSIS:\n"
21232 "\n"
21233 "plstyl(nms, mark, space)\n"
21234 "\n"
21235 "ARGUMENTS:\n"
21236 "\n"
21237 " nms (PLINT, input) : The number of mark and space elements in a\n"
21238 " line. Thus a simple broken line can be obtained by setting nms=1\n"
21239 " . A continuous line is specified by setting nms=0 .\n"
21240 "\n"
21241 " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21242 " segments during which the pen is down, measured in micrometers.\n"
21243 "\n"
21244 " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21245 " the segments during which the pen is up, measured in micrometers.\n"
21246 "\n"
21247 ""},
21248 { "plsvect", _wrap_plsvect, METH_VARARGS, "\n"
21249 "Set arrow style for vector plots\n"
21250 "\n"
21251 "DESCRIPTION:\n"
21252 "\n"
21253 " Set the style for the arrow used by plvect to plot vectors.\n"
21254 "\n"
21255 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21256 "\n"
21257 " This function is used in example 22.\n"
21258 "\n"
21259 "\n"
21260 "\n"
21261 "SYNOPSIS:\n"
21262 "\n"
21263 "plsvect(arrowx, arrowy, npts, fill)\n"
21264 "\n"
21265 "ARGUMENTS:\n"
21266 "\n"
21267 " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21268 " the x and y points which make up the arrow. The arrow is plotted\n"
21269 " by joining these points to form a polygon. The scaling assumes\n"
21270 " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21271 " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21272 " will be reset to its default.\n"
21273 "\n"
21274 " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21275 " arrowy.\n"
21276 "\n"
21277 " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21278 " fill is false then the arrow is open.\n"
21279 "\n"
21280 ""},
21281 { "plsvpa", _wrap_plsvpa, METH_VARARGS, "\n"
21282 "Specify viewport in absolute coordinates\n"
21283 "\n"
21284 "DESCRIPTION:\n"
21285 "\n"
21286 " Alternate routine to plvpor for setting up the viewport. This routine\n"
21287 " should be used only if the viewport is required to have a definite\n"
21288 " size in millimeters. The routine plgspa is useful for finding out the\n"
21289 " size of the current subpage.\n"
21290 "\n"
21291 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21292 "\n"
21293 " This function is used in example 10.\n"
21294 "\n"
21295 "\n"
21296 "\n"
21297 "SYNOPSIS:\n"
21298 "\n"
21299 "plsvpa(xmin, xmax, ymin, ymax)\n"
21300 "\n"
21301 "ARGUMENTS:\n"
21302 "\n"
21303 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21304 " viewport from the left-hand edge of the subpage in millimeters.\n"
21305 "\n"
21306 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21307 " viewport from the left-hand edge of the subpage in millimeters.\n"
21308 "\n"
21309 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21310 " viewport from the bottom edge of the subpage in millimeters.\n"
21311 "\n"
21312 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21313 " from the bottom edge of the subpage in millimeters.\n"
21314 "\n"
21315 ""},
21316 { "plsxax", _wrap_plsxax, METH_VARARGS, "\n"
21317 "Set x axis parameters\n"
21318 "\n"
21319 "DESCRIPTION:\n"
21320 "\n"
21321 " Sets values of the digmax and digits flags for the x axis. See the\n"
21322 " PLplot documentation for more information.\n"
21323 "\n"
21324 " Redacted form: plsxax(digmax, digits)\n"
21325 "\n"
21326 " This function is used in example 31.\n"
21327 "\n"
21328 "\n"
21329 "\n"
21330 "SYNOPSIS:\n"
21331 "\n"
21332 "plsxax(digmax, digits)\n"
21333 "\n"
21334 "ARGUMENTS:\n"
21335 "\n"
21336 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21337 " digits for the x axis. If nonzero, the printed label will be\n"
21338 " switched to a floating-point representation when the number of\n"
21339 " digits exceeds digmax.\n"
21340 "\n"
21341 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21342 " its value here has no effect since it is set only by plbox or\n"
21343 " plbox3. However, the user may obtain its value after a call to\n"
21344 " either of these functions by calling plgxax.\n"
21345 "\n"
21346 ""},
21347 { "plsyax", _wrap_plsyax, METH_VARARGS, "\n"
21348 "Set y axis parameters\n"
21349 "\n"
21350 "DESCRIPTION:\n"
21351 "\n"
21352 " Identical to plsxax, except that arguments are flags for y axis. See\n"
21353 " the description of plsxax for more detail.\n"
21354 "\n"
21355 " Redacted form: plsyax(digmax, digits)\n"
21356 "\n"
21357 " This function is used in examples 1, 14, and 31.\n"
21358 "\n"
21359 "\n"
21360 "\n"
21361 "SYNOPSIS:\n"
21362 "\n"
21363 "plsyax(digmax, digits)\n"
21364 "\n"
21365 "ARGUMENTS:\n"
21366 "\n"
21367 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21368 " digits for the y axis. If nonzero, the printed label will be\n"
21369 " switched to a floating-point representation when the number of\n"
21370 " digits exceeds digmax.\n"
21371 "\n"
21372 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21373 " its value here has no effect since it is set only by plbox or\n"
21374 " plbox3. However, the user may obtain its value after a call to\n"
21375 " either of these functions by calling plgyax.\n"
21376 "\n"
21377 ""},
21378 { "plsym", _wrap_plsym, METH_VARARGS, "\n"
21379 "Plot a glyph at the specified points\n"
21380 "\n"
21381 "DESCRIPTION:\n"
21382 "\n"
21383 " Plot a glyph at the specified points. (This function is largely\n"
21384 " superseded by plstring which gives access to many[!] more glyphs.)\n"
21385 "\n"
21386 " Redacted form: plsym(x, y, code)\n"
21387 "\n"
21388 " This function is used in example 7.\n"
21389 "\n"
21390 "\n"
21391 "\n"
21392 "SYNOPSIS:\n"
21393 "\n"
21394 "plsym(n, x, y, code)\n"
21395 "\n"
21396 "ARGUMENTS:\n"
21397 "\n"
21398 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21399 "\n"
21400 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21401 " the points.\n"
21402 "\n"
21403 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21404 " the points.\n"
21405 "\n"
21406 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21407 " to be plotted at each of the n points.\n"
21408 "\n"
21409 ""},
21410 { "plszax", _wrap_plszax, METH_VARARGS, "\n"
21411 "Set z axis parameters\n"
21412 "\n"
21413 "DESCRIPTION:\n"
21414 "\n"
21415 " Identical to plsxax, except that arguments are flags for z axis. See\n"
21416 " the description of plsxax for more detail.\n"
21417 "\n"
21418 " Redacted form: plszax(digmax, digits)\n"
21419 "\n"
21420 " This function is used in example 31.\n"
21421 "\n"
21422 "\n"
21423 "\n"
21424 "SYNOPSIS:\n"
21425 "\n"
21426 "plszax(digmax, digits)\n"
21427 "\n"
21428 "ARGUMENTS:\n"
21429 "\n"
21430 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21431 " digits for the z axis. If nonzero, the printed label will be\n"
21432 " switched to a floating-point representation when the number of\n"
21433 " digits exceeds digmax.\n"
21434 "\n"
21435 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21436 " its value here has no effect since it is set only by plbox or\n"
21437 " plbox3. However, the user may obtain its value after a call to\n"
21438 " either of these functions by calling plgzax.\n"
21439 "\n"
21440 ""},
21441 { "pltext", _wrap_pltext, METH_NOARGS, "\n"
21442 "Switch to text screen\n"
21443 "\n"
21444 "DESCRIPTION:\n"
21445 "\n"
21446 " Sets an interactive device to text mode, used in conjunction with\n"
21447 " plgra to allow graphics and text to be interspersed. On a device\n"
21448 " which supports separate text and graphics windows, this command causes\n"
21449 " control to be switched to the text window. This can be useful for\n"
21450 " printing diagnostic messages or getting user input, which would\n"
21451 " otherwise interfere with the plots. The program must switch back to\n"
21452 " the graphics window before issuing plot commands, as the text (or\n"
21453 " console) device will probably become quite confused otherwise. If\n"
21454 " already in text mode, this command is ignored. It is also ignored on\n"
21455 " devices which only support a single window or use a different method\n"
21456 " for shifting focus (see also plgra).\n"
21457 "\n"
21458 " Redacted form: pltext()\n"
21459 "\n"
21460 " This function is used in example 1.\n"
21461 "\n"
21462 "\n"
21463 "\n"
21464 "SYNOPSIS:\n"
21465 "\n"
21466 "pltext()\n"
21467 "\n"
21468 ""},
21469 { "pltimefmt", _wrap_pltimefmt, METH_O, "\n"
21470 "Set format for date / time labels\n"
21471 "\n"
21472 "DESCRIPTION:\n"
21473 "\n"
21474 " Sets the format for date / time labels. To enable date / time format\n"
21475 " labels see the options to plbox, plbox3, and plenv.\n"
21476 "\n"
21477 " Redacted form: pltimefmt(fmt)\n"
21478 "\n"
21479 " This function is used in example 29.\n"
21480 "\n"
21481 "\n"
21482 "\n"
21483 "SYNOPSIS:\n"
21484 "\n"
21485 "pltimefmt(fmt)\n"
21486 "\n"
21487 "ARGUMENTS:\n"
21488 "\n"
21489 " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21490 " interpreted similarly to the format specifier of typical system\n"
21491 " strftime routines except that PLplot ignores locale and also\n"
21492 " supplies some useful extensions in the context of plotting. All\n"
21493 " text in the string is printed as-is other than conversion\n"
21494 " specifications which take the form of a '%' character followed by\n"
21495 " further conversion specification character. The conversion\n"
21496 " specifications which are similar to those provided by system\n"
21497 " strftime routines are the following: %a: The abbreviated (English)\n"
21498 " weekday name.\n"
21499 " %A: The full (English) weekday name.\n"
21500 " %b: The abbreviated (English) month name.\n"
21501 " %B: The full (English) month name.\n"
21502 " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21503 " %C: The century number (year/100) as a 2-digit integer.\n"
21504 " %d: The day of the month as a decimal number (range 01 to 31).\n"
21505 " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21506 " %e: Like %d, but a leading zero is replaced by a space.\n"
21507 " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21508 " %h: Equivalent to %b.\n"
21509 " %H: The hour as a decimal number using a 24-hour clock (range\n"
21510 " 00 to 23).\n"
21511 " %I: The hour as a decimal number using a 12-hour clock (range\n"
21512 " 01 to 12).\n"
21513 " %j: The day of the year as a decimal number (range 001 to\n"
21514 " 366).\n"
21515 " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21516 " 23); single digits are preceded by a blank. (See also %H.)\n"
21517 " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21518 " 12); single digits are preceded by a blank. (See also %I.)\n"
21519 " %m: The month as a decimal number (range 01 to 12).\n"
21520 " %M: The minute as a decimal number (range 00 to 59).\n"
21521 " %n: A newline character.\n"
21522 " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21523 " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21524 " %r: Equivalent to %I:%M:%S %p.\n"
21525 " %R: The time in 24-hour notation (%H:%M). For a version\n"
21526 " including the seconds, see %T below.\n"
21527 " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21528 " +0000 (UTC).\n"
21529 " %S: The second as a decimal number (range 00 to 60). (The\n"
21530 " range is up to 60 to allow for occasional leap seconds.)\n"
21531 " %t: A tab character.\n"
21532 " %T: The time in 24-hour notation (%H:%M:%S).\n"
21533 " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21534 " being 1. See also %w.\n"
21535 " %U: The week number of the current year as a decimal number,\n"
21536 " range 00 to 53, starting with the first Sunday as the first\n"
21537 " day of week 01. See also %V and %W.\n"
21538 " %v: Equivalent to %e-%b-%Y.\n"
21539 " %V: The ISO 8601 week number of the current year as a decimal\n"
21540 " number, range 01 to 53, where week 1 is the first week that\n"
21541 " has at least 4 days in the new year. See also %U and %W.\n"
21542 " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21543 " being 0. See also %u.\n"
21544 " %W: The week number of the current year as a decimal number,\n"
21545 " range 00 to 53, starting with the first Monday as the first\n"
21546 " day of week 01.\n"
21547 " %x: Equivalent to %a %b %d %Y.\n"
21548 " %X: Equivalent to %T.\n"
21549 " %y: The year as a decimal number without a century (range 00\n"
21550 " to 99).\n"
21551 " %Y: The year as a decimal number including a century.\n"
21552 " %z: The UTC time-zone string = \"+0000\".\n"
21553 " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21554 " %+: The UTC date and time in default format of the Unix date\n"
21555 " command which is equivalent to %a %b %d %T %Z %Y.\n"
21556 " %%: A literal \"%\" character.\n"
21557 " The conversion specifications which are extensions to those normally\n"
21558 " provided by system strftime routines are the following: %(0-9):\n"
21559 " The fractional part of the seconds field (including leading\n"
21560 " decimal point) to the specified accuracy. Thus %S%3 would give\n"
21561 " seconds to millisecond accuracy (00.000).\n"
21562 " %.: The fractional part of the seconds field (including\n"
21563 " leading decimal point) to the maximum available accuracy. Thus\n"
21564 " %S%. would give seconds with fractional part up to 9 decimal\n"
21565 " places if available.\n"
21566 "\n"
21567 ""},
21568 { "plvasp", _wrap_plvasp, METH_O, "\n"
21569 "Specify viewport using aspect ratio only\n"
21570 "\n"
21571 "DESCRIPTION:\n"
21572 "\n"
21573 " Selects the largest viewport with the given aspect ratio within the\n"
21574 " subpage that leaves a standard margin (left-hand margin of eight\n"
21575 " character heights, and a margin around the other three sides of five\n"
21576 " character heights).\n"
21577 "\n"
21578 " Redacted form: plvasp(aspect)\n"
21579 "\n"
21580 " This function is used in example 13.\n"
21581 "\n"
21582 "\n"
21583 "\n"
21584 "SYNOPSIS:\n"
21585 "\n"
21586 "plvasp(aspect)\n"
21587 "\n"
21588 "ARGUMENTS:\n"
21589 "\n"
21590 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21591 " axis of resulting viewport.\n"
21592 "\n"
21593 ""},
21594 { "plvect", _wrap_plvect, METH_VARARGS, "\n"
21595 "Vector plot\n"
21596 "\n"
21597 "DESCRIPTION:\n"
21598 "\n"
21599 " Draws a plot of vector data contained in the matrices (\n"
21600 " u[\n"
21601 " nx][\n"
21602 " ny],\n"
21603 " v[\n"
21604 " nx][\n"
21605 " ny]) . The scaling factor for the vectors is given by scale. A\n"
21606 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
21607 " additional data required by the transformation routine to map indices\n"
21608 " within the matrices to the world coordinates. The style of the vector\n"
21609 " arrow may be set using plsvect.\n"
21610 "\n"
21611 " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
21612 " discussion) the pltr, pltr_data callback arguments are sometimes\n"
21613 " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
21614 " with either one or two dimensions.\n"
21615 "\n"
21616 " This function is used in example 22.\n"
21617 "\n"
21618 "\n"
21619 "\n"
21620 "SYNOPSIS:\n"
21621 "\n"
21622 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
21623 "\n"
21624 "ARGUMENTS:\n"
21625 "\n"
21626 " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
21627 " and y components of the vector data to be plotted.\n"
21628 "\n"
21629 " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
21630 "\n"
21631 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
21632 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
21633 " automatically calculated for the data. If scale < 0 then the\n"
21634 " scaling factor is automatically calculated for the data and then\n"
21635 " multiplied by -\n"
21636 " scale. If scale > 0 then the scaling factor is set to scale.\n"
21637 "\n"
21638 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
21639 " defines the transformation between the zero-based indices of the\n"
21640 " matrices u and v and world coordinates.For the C case,\n"
21641 " transformation functions are provided in the PLplot library: pltr0\n"
21642 " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
21643 " mappings respectively defined by vectors and matrices. In\n"
21644 " addition, C callback routines for the transformation can be\n"
21645 " supplied by the user such as the mypltr function in\n"
21646 " examples/c/x09c.c which provides a general linear transformation\n"
21647 " between index coordinates and world coordinates.For languages\n"
21648 " other than C you should consult the PLplot documentation for the\n"
21649 " details concerning how PLTRANSFORM_callback arguments are\n"
21650 " interfaced. However, in general, a particular pattern of\n"
21651 " callback-associated arguments such as a tr vector with 6 elements;\n"
21652 " xg and yg vectors; or xg and yg matrices are respectively\n"
21653 " interfaced to a linear-transformation routine similar to the above\n"
21654 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
21655 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
21656 " support native language callbacks for handling index to\n"
21657 " world-coordinate transformations. Examples of these various\n"
21658 " approaches are given in examples/<language>x09*,\n"
21659 " examples/<language>x16*, examples/<language>x20*,\n"
21660 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
21661 " supported languages.\n"
21662 "\n"
21663 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
21664 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
21665 " that is externally supplied.\n"
21666 "\n"
21667 ""},
21668 { "plvpas", _wrap_plvpas, METH_VARARGS, "\n"
21669 "Specify viewport using coordinates and aspect ratio\n"
21670 "\n"
21671 "DESCRIPTION:\n"
21672 "\n"
21673 " Device-independent routine for setting up the viewport. The viewport\n"
21674 " is chosen to be the largest with the given aspect ratio that fits\n"
21675 " within the specified region (in terms of normalized subpage\n"
21676 " coordinates). This routine is functionally equivalent to plvpor when\n"
21677 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
21678 " routine reserves no extra space at the edges for labels.\n"
21679 "\n"
21680 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21681 "\n"
21682 " This function is used in example 9.\n"
21683 "\n"
21684 "\n"
21685 "\n"
21686 "SYNOPSIS:\n"
21687 "\n"
21688 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
21689 "\n"
21690 "ARGUMENTS:\n"
21691 "\n"
21692 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21693 " left-hand edge of the viewport.\n"
21694 "\n"
21695 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21696 " right-hand edge of the viewport.\n"
21697 "\n"
21698 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21699 " bottom edge of the viewport.\n"
21700 "\n"
21701 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21702 " edge of the viewport.\n"
21703 "\n"
21704 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
21705 " axis.\n"
21706 "\n"
21707 ""},
21708 { "plvpor", _wrap_plvpor, METH_VARARGS, "\n"
21709 "Specify viewport using normalized subpage coordinates\n"
21710 "\n"
21711 "DESCRIPTION:\n"
21712 "\n"
21713 " Device-independent routine for setting up the viewport. This defines\n"
21714 " the viewport in terms of normalized subpage coordinates which run from\n"
21715 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
21716 " current subpage. Use the alternate routine plsvpa in order to create\n"
21717 " a viewport of a definite size.\n"
21718 "\n"
21719 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
21720 "\n"
21721 " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
21722 " 24, 26, 27, and 31.\n"
21723 "\n"
21724 "\n"
21725 "\n"
21726 "SYNOPSIS:\n"
21727 "\n"
21728 "plvpor(xmin, xmax, ymin, ymax)\n"
21729 "\n"
21730 "ARGUMENTS:\n"
21731 "\n"
21732 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
21733 " left-hand edge of the viewport.\n"
21734 "\n"
21735 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
21736 " right-hand edge of the viewport.\n"
21737 "\n"
21738 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
21739 " bottom edge of the viewport.\n"
21740 "\n"
21741 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
21742 " edge of the viewport.\n"
21743 "\n"
21744 ""},
21745 { "plvsta", _wrap_plvsta, METH_NOARGS, "\n"
21746 "Select standard viewport\n"
21747 "\n"
21748 "DESCRIPTION:\n"
21749 "\n"
21750 " Selects the largest viewport within the subpage that leaves a standard\n"
21751 " margin (left-hand margin of eight character heights, and a margin\n"
21752 " around the other three sides of five character heights).\n"
21753 "\n"
21754 " Redacted form: plvsta()\n"
21755 "\n"
21756 " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
21757 "\n"
21758 "\n"
21759 "\n"
21760 "SYNOPSIS:\n"
21761 "\n"
21762 "plvsta()\n"
21763 "\n"
21764 ""},
21765 { "plw3d", _wrap_plw3d, METH_VARARGS, "\n"
21766 "Configure the transformations required for projecting a 3D surface on a 2D window\n"
21767 "\n"
21768 "DESCRIPTION:\n"
21769 "\n"
21770 " Configure the transformations required for projecting a 3D surface on\n"
21771 " an existing 2D window. Those transformations (see the PLplot\n"
21772 " documentation) are done to a rectangular cuboid enclosing the 3D\n"
21773 " surface which has its limits expressed in 3D world coordinates and\n"
21774 " also normalized 3D coordinates (used for interpreting the altitude and\n"
21775 " azimuth of the viewing angle). The transformations consist of the\n"
21776 " linear transform from 3D world coordinates to normalized 3D\n"
21777 " coordinates, and the 3D rotation of normalized coordinates required to\n"
21778 " align the pole of the new 3D coordinate system with the viewing\n"
21779 " direction specified by altitude and azimuth so that x and y of the\n"
21780 " surface elements in that transformed coordinate system are the\n"
21781 " projection of the 3D surface with given viewing direction on the 2D\n"
21782 " window.\n"
21783 "\n"
21784 " The enclosing rectangular cuboid for the surface plot is defined by\n"
21785 " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
21786 " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
21787 " sizes of basex by basey by height so that xmin maps to -\n"
21788 " basex/2, xmax maps to basex/2, ymin maps to -\n"
21789 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
21790 " The resulting rectangular cuboid in normalized coordinates is then\n"
21791 " viewed by an observer at altitude alt and azimuth az. This routine\n"
21792 " must be called before plbox3 or any of the 3D surface plotting\n"
21793 " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
21794 " plsurf3dl or plfill3.\n"
21795 "\n"
21796 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
21797 " zmin, zmax, alt, az)\n"
21798 "\n"
21799 " This function is examples 8, 11, 18, and 21.\n"
21800 "\n"
21801 "\n"
21802 "\n"
21803 "SYNOPSIS:\n"
21804 "\n"
21805 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
21806 "\n"
21807 "ARGUMENTS:\n"
21808 "\n"
21809 " basex (PLFLT, input) : The normalized x coordinate size of the\n"
21810 " rectangular cuboid.\n"
21811 "\n"
21812 " basey (PLFLT, input) : The normalized y coordinate size of the\n"
21813 " rectangular cuboid.\n"
21814 "\n"
21815 " height (PLFLT, input) : The normalized z coordinate size of the\n"
21816 " rectangular cuboid.\n"
21817 "\n"
21818 " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
21819 " rectangular cuboid.\n"
21820 "\n"
21821 " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
21822 " rectangular cuboid.\n"
21823 "\n"
21824 " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
21825 " rectangular cuboid.\n"
21826 "\n"
21827 " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
21828 " rectangular cuboid.\n"
21829 "\n"
21830 " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
21831 " rectangular cuboid.\n"
21832 "\n"
21833 " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
21834 " rectangular cuboid.\n"
21835 "\n"
21836 " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
21837 " plane of the rectangular cuboid in normalized coordinates.\n"
21838 "\n"
21839 " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
21840 " rectangular cuboid in normalized coordinates. When az=0, the\n"
21841 " observer is looking face onto the zx plane of the rectangular\n"
21842 " cuboid in normalized coordinates, and as az is increased, the\n"
21843 " observer moves clockwise around that cuboid when viewed from above\n"
21844 " the xy plane.\n"
21845 "\n"
21846 ""},
21847 { "plwidth", _wrap_plwidth, METH_O, "\n"
21848 "Set pen width\n"
21849 "\n"
21850 "DESCRIPTION:\n"
21851 "\n"
21852 " Sets the pen width.\n"
21853 "\n"
21854 " Redacted form: plwidth(width)\n"
21855 "\n"
21856 " This function is used in examples 1 and 2.\n"
21857 "\n"
21858 "\n"
21859 "\n"
21860 "SYNOPSIS:\n"
21861 "\n"
21862 "plwidth(width)\n"
21863 "\n"
21864 "ARGUMENTS:\n"
21865 "\n"
21866 " width (PLFLT, input) : The desired pen width. If width is negative\n"
21867 " or the same as the previous value no action is taken. width = 0.\n"
21868 " should be interpreted as as the minimum valid pen width for the\n"
21869 " device. The interpretation of positive width values is also\n"
21870 " device dependent.\n"
21871 "\n"
21872 ""},
21873 { "plwind", _wrap_plwind, METH_VARARGS, "\n"
21874 "Specify window\n"
21875 "\n"
21876 "DESCRIPTION:\n"
21877 "\n"
21878 " Specify the window, i.e., the world coordinates of the edges of the\n"
21879 " viewport.\n"
21880 "\n"
21881 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
21882 "\n"
21883 " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
21884 " 29, and 31.\n"
21885 "\n"
21886 "\n"
21887 "\n"
21888 "SYNOPSIS:\n"
21889 "\n"
21890 "plwind(xmin, xmax, ymin, ymax)\n"
21891 "\n"
21892 "ARGUMENTS:\n"
21893 "\n"
21894 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
21895 " of the viewport.\n"
21896 "\n"
21897 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
21898 " of the viewport.\n"
21899 "\n"
21900 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
21901 " the viewport.\n"
21902 "\n"
21903 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
21904 " viewport.\n"
21905 "\n"
21906 ""},
21907 { "plxormod", _wrap_plxormod, METH_O, "\n"
21908 "Enter or leave xor mode\n"
21909 "\n"
21910 "DESCRIPTION:\n"
21911 "\n"
21912 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
21913 " those drivers (e.g., the xwin driver) that support it. Enables\n"
21914 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
21915 " is not capable of xor operation it returns a status of false.\n"
21916 "\n"
21917 " Redacted form: plxormod(mode, status)\n"
21918 "\n"
21919 " This function is used in examples 1 and 20.\n"
21920 "\n"
21921 "\n"
21922 "\n"
21923 "SYNOPSIS:\n"
21924 "\n"
21925 "plxormod(mode, status)\n"
21926 "\n"
21927 "ARGUMENTS:\n"
21928 "\n"
21929 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
21930 " is false means leave xor mode.\n"
21931 "\n"
21932 " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
21933 " modestatus of true (false) means driver is capable (incapable) of\n"
21934 " xor mode.\n"
21935 "\n"
21936 ""},
21937 { "plmap", _wrap_plmap, METH_VARARGS, "\n"
21938 "Plot continental outline or shapefile data in world coordinates\n"
21939 "\n"
21940 "DESCRIPTION:\n"
21941 "\n"
21942 " Plots continental outlines or shapefile data in world coordinates. A\n"
21943 " demonstration of how to use this function to create different\n"
21944 " projections can be found in examples/c/x19c. PLplot is provided with\n"
21945 " basic coastal outlines and USA state borders. To use the map\n"
21946 " functionality PLplot must be compiled with the shapelib library.\n"
21947 " Shapefiles have become a popular standard for geographical data and\n"
21948 " data in this format can be easily found from a number of online\n"
21949 " sources. Shapefile data is actually provided as three or more files\n"
21950 " with the same filename, but different extensions. The .shp and .shx\n"
21951 " files are required for plotting Shapefile data with PLplot.\n"
21952 "\n"
21953 " PLplot currently supports the point, multipoint, polyline and polygon\n"
21954 " objects within shapefiles. However holes in polygons are not\n"
21955 " supported. When plmap is used the type of object is derived from the\n"
21956 " shapefile, if you wish to override the type then use one of the other\n"
21957 " plmap variants. The built in maps have line data only.\n"
21958 "\n"
21959 " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
21960 "\n"
21961 " This function is used in example 19.\n"
21962 "\n"
21963 "\n"
21964 "\n"
21965 "SYNOPSIS:\n"
21966 "\n"
21967 "plmap(mapform, name, minx, maxx, miny, maxy)\n"
21968 "\n"
21969 "ARGUMENTS:\n"
21970 "\n"
21971 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
21972 " transform the original map data coordinates to a new coordinate\n"
21973 " system. The PLplot-supplied map data is provided as latitudes and\n"
21974 " longitudes; other Shapefile data may be provided in other\n"
21975 " coordinate systems as can be found in their .prj plain text files.\n"
21976 " For example, by using this transform we can change from a\n"
21977 " longitude, latitude coordinate to a polar stereographic\n"
21978 " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
21979 " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
21980 " corresponding y coordinates (latitudes for the PLplot supplied\n"
21981 " data). After the call to mapform(), x[] and y[] should be\n"
21982 " replaced by the corresponding plot coordinates. If no transform is\n"
21983 " desired, mapform can be replaced by NULL.\n"
21984 "\n"
21985 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
21986 " the type of map plotted. This is either one of the PLplot built-in\n"
21987 " maps or the file name of a set of Shapefile files without the file\n"
21988 " extensions. For the PLplot built-in maps the possible values are:\n"
21989 " \"globe\" -- continental outlines\n"
21990 " \"usa\" -- USA and state boundaries\n"
21991 " \"cglobe\" -- continental outlines and countries\n"
21992 " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
21993 "\n"
21994 "\n"
21995 " minx (PLFLT, input) : The minimum x value of map elements to be\n"
21996 " drawn. The units must match the shapefile (built in maps are\n"
21997 " degrees lat/lon). Objects in the file which do not encroach on the\n"
21998 " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
21999 " note this is simply an optimisation, not a clipping so for objects\n"
22000 " with some points inside the box and some points outside the box\n"
22001 " all the points will be rendered. These parameters also define\n"
22002 " latitude and longitude wrapping for shapefiles using these units.\n"
22003 " Longitude points will be wrapped by integer multiples of 360\n"
22004 " degrees to place them in the box. This allows the same data to be\n"
22005 " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
22006 " you plot from -180-540 you will get two cycles of data drawn. The\n"
22007 " value of minx must be less than the value of maxx. Passing in a\n"
22008 " nan, max/-max floating point number or +/-infinity will case the\n"
22009 " bounding box from the shapefile to be used.\n"
22010 "\n"
22011 " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22012 " drawn - see minx.\n"
22013 "\n"
22014 " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22015 " drawn - see minx.\n"
22016 "\n"
22017 " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22018 " drawn - see minx.\n"
22019 "\n"
22020 ""},
22021 { "plmapline", _wrap_plmapline, METH_VARARGS, "\n"
22022 "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22023 "\n"
22024 "DESCRIPTION:\n"
22025 "\n"
22026 " Plot all or a subset of Shapefile data using lines in world\n"
22027 " coordinates. Our 19th standard example demonstrates how to use this\n"
22028 " function. This function plots data from a Shapefile using lines as in\n"
22029 " plmap, however it also has the option of also only drawing specified\n"
22030 " elements from the Shapefile. The vector of indices of the required\n"
22031 " elements are passed as a function argument. The Shapefile data should\n"
22032 " include a metadata file (extension.dbf) listing all items within the\n"
22033 " Shapefile. This file can be opened by most popular spreadsheet\n"
22034 " programs and can be used to decide which indices to pass to this\n"
22035 " function.\n"
22036 "\n"
22037 " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22038 " plotentries)\n"
22039 "\n"
22040 " This function is used in example 19.\n"
22041 "\n"
22042 "\n"
22043 "\n"
22044 "SYNOPSIS:\n"
22045 "\n"
22046 "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22047 "\n"
22048 "ARGUMENTS:\n"
22049 "\n"
22050 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22051 " transform the coordinates given in the shapefile into a plot\n"
22052 " coordinate system. By using this transform, we can change from a\n"
22053 " longitude, latitude coordinate to a polar stereographic project,\n"
22054 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22055 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22056 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22057 " plot coordinates. If no transform is desired, mapform can be\n"
22058 " replaced by NULL.\n"
22059 "\n"
22060 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22061 " the file name of a set of Shapefile files without the file\n"
22062 " extension.\n"
22063 "\n"
22064 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22065 " be in the same units as used by the Shapefile. You could use a\n"
22066 " very large negative number to plot everything, but you can improve\n"
22067 " performance by limiting the area drawn. The units must match those\n"
22068 " of the Shapefile projection, which may be for example longitude or\n"
22069 " distance. The value of minx must be less than the value of maxx.\n"
22070 "\n"
22071 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22072 " use a very large number to plot everything, but you can improve\n"
22073 " performance by limiting the area drawn.\n"
22074 "\n"
22075 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22076 " be in the same units as used by the Shapefile. You could use a\n"
22077 " very large negative number to plot everything, but you can improve\n"
22078 " performance by limiting the area drawn. The units must match those\n"
22079 " of the Shapefile projection, which may be for example latitude or\n"
22080 " distance. The value of miny must be less than the value of maxy.\n"
22081 "\n"
22082 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22083 " use a very large number to plot everything, but you can improve\n"
22084 " performance by limiting the area drawn.\n"
22085 "\n"
22086 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22087 " zero-based indices of the Shapefile elements which will be drawn.\n"
22088 " Setting\n"
22089 " plotentries to NULL will plot all elements of the Shapefile.\n"
22090 "\n"
22091 " nplotentries (PLINT, input) : The number of items in\n"
22092 " plotentries. Ignored if\n"
22093 " plotentries is NULL.\n"
22094 "\n"
22095 ""},
22096 { "plmapstring", _wrap_plmapstring, METH_VARARGS, "\n"
22097 "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22098 "\n"
22099 "DESCRIPTION:\n"
22100 "\n"
22101 " As per plmapline, however the items are plotted as strings or points\n"
22102 " in the same way as plstring.\n"
22103 "\n"
22104 " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22105 " maxy, plotentries)\n"
22106 "\n"
22107 " This function is not used in any examples.\n"
22108 "\n"
22109 "\n"
22110 "\n"
22111 "SYNOPSIS:\n"
22112 "\n"
22113 "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22114 "\n"
22115 "ARGUMENTS:\n"
22116 "\n"
22117 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22118 " transform the coordinates given in the shapefile into a plot\n"
22119 " coordinate system. By using this transform, we can change from a\n"
22120 " longitude, latitude coordinate to a polar stereographic project,\n"
22121 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22122 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22123 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22124 " plot coordinates. If no transform is desired, mapform can be\n"
22125 " replaced by NULL.\n"
22126 "\n"
22127 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22128 " the file name of a set of Shapefile files without the file\n"
22129 " extension.\n"
22130 "\n"
22131 " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22132 " drawn.\n"
22133 "\n"
22134 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22135 " be in the same units as used by the Shapefile. You could use a\n"
22136 " very large negative number to plot everything, but you can improve\n"
22137 " performance by limiting the area drawn. The units must match those\n"
22138 " of the Shapefile projection, which may be for example longitude or\n"
22139 " distance. The value of minx must be less than the value of maxx.\n"
22140 "\n"
22141 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22142 " use a very large number to plot everything, but you can improve\n"
22143 " performance by limiting the area drawn.\n"
22144 "\n"
22145 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22146 " be in the same units as used by the Shapefile. You could use a\n"
22147 " very large negative number to plot everything, but you can improve\n"
22148 " performance by limiting the area drawn. The units must match those\n"
22149 " of the Shapefile projection, which may be for example latitude or\n"
22150 " distance. The value of miny must be less than the value of maxy.\n"
22151 "\n"
22152 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22153 " use a very large number to plot everything, but you can improve\n"
22154 " performance by limiting the area drawn.\n"
22155 "\n"
22156 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22157 " zero-based indices of the Shapefile elements which will be drawn.\n"
22158 " Setting\n"
22159 " plotentries to NULL will plot all elements of the Shapefile.\n"
22160 "\n"
22161 " nplotentries (PLINT, input) : The number of items in\n"
22162 " plotentries. Ignored if\n"
22163 " plotentries is NULL.\n"
22164 "\n"
22165 ""},
22166 { "plmaptex", _wrap_plmaptex, METH_VARARGS, "\n"
22167 "Draw text at points defined by Shapefile data in world coordinates\n"
22168 "\n"
22169 "DESCRIPTION:\n"
22170 "\n"
22171 " As per plmapline, however the items are plotted as text in the same\n"
22172 " way as plptex.\n"
22173 "\n"
22174 " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22175 " miny, maxy, plotentry)\n"
22176 "\n"
22177 " This function is used in example 19.\n"
22178 "\n"
22179 "\n"
22180 "\n"
22181 "SYNOPSIS:\n"
22182 "\n"
22183 "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22184 "\n"
22185 "ARGUMENTS:\n"
22186 "\n"
22187 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22188 " transform the coordinates given in the shapefile into a plot\n"
22189 " coordinate system. By using this transform, we can change from a\n"
22190 " longitude, latitude coordinate to a polar stereographic project,\n"
22191 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22192 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22193 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22194 " plot coordinates. If no transform is desired, mapform can be\n"
22195 " replaced by NULL.\n"
22196 "\n"
22197 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22198 " the file name of a set of Shapefile files without the file\n"
22199 " extension.\n"
22200 "\n"
22201 " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22202 " dy/dx.\n"
22203 "\n"
22204 " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22205 " dy/dx.\n"
22206 "\n"
22207 " just (PLFLT, input) : Set the justification of the text. The value\n"
22208 " given will be the fraction of the distance along the string that\n"
22209 " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22210 " centralized text and 1.0 gives right aligned text.\n"
22211 "\n"
22212 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22213 "\n"
22214 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22215 " be in the same units as used by the Shapefile. You could use a\n"
22216 " very large negative number to plot everything, but you can improve\n"
22217 " performance by limiting the area drawn. The units must match those\n"
22218 " of the Shapefile projection, which may be for example longitude or\n"
22219 " distance. The value of minx must be less than the value of maxx.\n"
22220 "\n"
22221 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22222 " use a very large number to plot everything, but you can improve\n"
22223 " performance by limiting the area drawn.\n"
22224 "\n"
22225 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22226 " be in the same units as used by the Shapefile. You could use a\n"
22227 " very large negative number to plot everything, but you can improve\n"
22228 " performance by limiting the area drawn. The units must match those\n"
22229 " of the Shapefile projection, which may be for example latitude or\n"
22230 " distance. The value of miny must be less than the value of maxy.\n"
22231 "\n"
22232 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22233 " use a very large number to plot everything, but you can improve\n"
22234 " performance by limiting the area drawn.\n"
22235 "\n"
22236 " plotentry (PLINT, input) : An integer indicating which text string\n"
22237 " of the Shapefile (zero indexed) will be drawn.\n"
22238 "\n"
22239 ""},
22240 { "plmapfill", _wrap_plmapfill, METH_VARARGS, "\n"
22241 "Plot all or a subset of Shapefile data, filling the polygons\n"
22242 "\n"
22243 "DESCRIPTION:\n"
22244 "\n"
22245 " As per plmapline, however the items are filled in the same way as\n"
22246 " plfill.\n"
22247 "\n"
22248 " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22249 " plotentries)\n"
22250 "\n"
22251 " This function is used in example 19.\n"
22252 "\n"
22253 "\n"
22254 "\n"
22255 "SYNOPSIS:\n"
22256 "\n"
22257 "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22258 "\n"
22259 "ARGUMENTS:\n"
22260 "\n"
22261 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22262 " transform the coordinates given in the shapefile into a plot\n"
22263 " coordinate system. By using this transform, we can change from a\n"
22264 " longitude, latitude coordinate to a polar stereographic project,\n"
22265 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22266 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22267 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22268 " plot coordinates. If no transform is desired, mapform can be\n"
22269 " replaced by NULL.\n"
22270 "\n"
22271 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22272 " the file name of a set of Shapefile files without the file\n"
22273 " extension.\n"
22274 "\n"
22275 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22276 " be in the same units as used by the Shapefile. You could use a\n"
22277 " very large negative number to plot everything, but you can improve\n"
22278 " performance by limiting the area drawn. The units must match those\n"
22279 " of the Shapefile projection, which may be for example longitude or\n"
22280 " distance. The value of minx must be less than the value of maxx.\n"
22281 "\n"
22282 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22283 " use a very large number to plot everything, but you can improve\n"
22284 " performance by limiting the area drawn.\n"
22285 "\n"
22286 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22287 " be in the same units as used by the Shapefile. You could use a\n"
22288 " very large negative number to plot everything, but you can improve\n"
22289 " performance by limiting the area drawn. The units must match those\n"
22290 " of the Shapefile projection, which may be for example latitude or\n"
22291 " distance. The value of miny must be less than the value of maxy.\n"
22292 "\n"
22293 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22294 " use a very large number to plot everything, but you can improve\n"
22295 " performance by limiting the area drawn.\n"
22296 "\n"
22297 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22298 " zero-based indices of the Shapefile elements which will be drawn.\n"
22299 " Setting\n"
22300 " plotentries to NULL will plot all elements of the Shapefile.\n"
22301 "\n"
22302 " nplotentries (PLINT, input) : The number of items in\n"
22303 " plotentries. Ignored if\n"
22304 " plotentries is NULL.\n"
22305 "\n"
22306 ""},
22307 { "plmeridians", _wrap_plmeridians, METH_VARARGS, "\n"
22308 "Plot latitude and longitude lines\n"
22309 "\n"
22310 "DESCRIPTION:\n"
22311 "\n"
22312 " Displays latitude and longitude on the current plot. The lines are\n"
22313 " plotted in the current color and line style.\n"
22314 "\n"
22315 " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22316 " minlat, maxlat)\n"
22317 "\n"
22318 " This function is used in example 19.\n"
22319 "\n"
22320 "\n"
22321 "\n"
22322 "SYNOPSIS:\n"
22323 "\n"
22324 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22325 "\n"
22326 "ARGUMENTS:\n"
22327 "\n"
22328 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22329 " transform the coordinate longitudes and latitudes to a plot\n"
22330 " coordinate system. By using this transform, we can change from a\n"
22331 " longitude, latitude coordinate to a polar stereographic project,\n"
22332 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22333 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22334 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22335 " plot coordinates. If no transform is desired, mapform can be\n"
22336 " replaced by NULL.\n"
22337 "\n"
22338 " dlong (PLFLT, input) : The interval in degrees at which the\n"
22339 " longitude lines are to be plotted.\n"
22340 "\n"
22341 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22342 " lines are to be plotted.\n"
22343 "\n"
22344 " minlong (PLFLT, input) : The value of the longitude on the left\n"
22345 " side of the plot. The value of minlong must be less than the value\n"
22346 " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22347 " equal to 360.\n"
22348 "\n"
22349 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22350 " side of the plot.\n"
22351 "\n"
22352 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22353 " background. One can always use -90.0 as the boundary outside the\n"
22354 " plot window will be automatically eliminated. However, the\n"
22355 " program will be faster if one can reduce the size of the\n"
22356 " background plotted.\n"
22357 "\n"
22358 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22359 " background. One can always use 90.0 as the boundary outside the\n"
22360 " plot window will be automatically eliminated.\n"
22361 "\n"
22362 ""},
22363 { "plimage", _wrap_plimage, METH_VARARGS, "\n"
22364 "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22365 "\n"
22366 "DESCRIPTION:\n"
22367 "\n"
22368 " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22369 " automatically adjusted to use the maximum and minimum values in idata\n"
22370 " as valuemin and valuemax in a call to plimagefr.\n"
22371 "\n"
22372 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22373 " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22374 "\n"
22375 "\n"
22376 " This function is used in example 20.\n"
22377 "\n"
22378 "\n"
22379 "\n"
22380 "SYNOPSIS:\n"
22381 "\n"
22382 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22383 "\n"
22384 "ARGUMENTS:\n"
22385 "\n"
22386 " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22387 " to plot. Should have dimensions of\n"
22388 " nx by\n"
22389 " ny.\n"
22390 "\n"
22391 " nx, ny (PLINT, input) : Dimensions of idata\n"
22392 "\n"
22393 " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22394 " are linearly transformed to these world coordinate ranges such\n"
22395 " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22396 " - 1] corresponds to (xmax, ymax).\n"
22397 "\n"
22398 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22399 " (inclusive) will be plotted.\n"
22400 "\n"
22401 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22402 " points whose plot coordinates fall inside the window of (Dxmin,\n"
22403 " Dymin) to (Dxmax, Dymax).\n"
22404 "\n"
22405 ""},
22406 { "plimagefr", _wrap_plimagefr, METH_VARARGS, "\n"
22407 "Plot a 2D matrix using cmap1\n"
22408 "\n"
22409 "DESCRIPTION:\n"
22410 "\n"
22411 " Plot a 2D matrix using cmap1.\n"
22412 "\n"
22413 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22414 " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22415 "\n"
22416 "\n"
22417 " This function is used in example 20.\n"
22418 "\n"
22419 "\n"
22420 "\n"
22421 "SYNOPSIS:\n"
22422 "\n"
22423 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22424 "\n"
22425 "ARGUMENTS:\n"
22426 "\n"
22427 " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22428 " plot. Should have dimensions of\n"
22429 " nx by\n"
22430 " ny.\n"
22431 "\n"
22432 " nx, ny (PLINT, input) : Dimensions of idata\n"
22433 "\n"
22434 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22435 " pltr below for how these arguments are used (only for the special case\n"
22436 " when the callback function\n"
22437 " pltr is not supplied).\n"
22438 "\n"
22439 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22440 " (inclusive) will be plotted.\n"
22441 "\n"
22442 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22443 " values to use for value to color mappings. A datum equal to or\n"
22444 " less than valuemin will be plotted with color 0.0, while a datum\n"
22445 " equal to or greater than valuemax will be plotted with color 1.0.\n"
22446 " Data between valuemin and valuemax map linearly to colors in the\n"
22447 " range (0.0-1.0).\n"
22448 "\n"
22449 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22450 " defines the transformation between the zero-based indices of the\n"
22451 " matrix idata and world coordinates. If\n"
22452 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22453 " indices of idata are mapped to the range\n"
22454 " xmin through\n"
22455 " xmax and the y indices of idata are mapped to the range\n"
22456 " ymin through\n"
22457 " ymax.For the C case, transformation functions are provided in the\n"
22458 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22459 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22460 " matrices. In addition, C callback routines for the transformation\n"
22461 " can be supplied by the user such as the mypltr function in\n"
22462 " examples/c/x09c.c which provides a general linear transformation\n"
22463 " between index coordinates and world coordinates.For languages\n"
22464 " other than C you should consult the PLplot documentation for the\n"
22465 " details concerning how PLTRANSFORM_callback arguments are\n"
22466 " interfaced. However, in general, a particular pattern of\n"
22467 " callback-associated arguments such as a tr vector with 6 elements;\n"
22468 " xg and yg vectors; or xg and yg matrices are respectively\n"
22469 " interfaced to a linear-transformation routine similar to the above\n"
22470 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22471 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22472 " support native language callbacks for handling index to\n"
22473 " world-coordinate transformations. Examples of these various\n"
22474 " approaches are given in examples/<language>x09*,\n"
22475 " examples/<language>x16*, examples/<language>x20*,\n"
22476 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22477 " supported languages.\n"
22478 "\n"
22479 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22480 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22481 " externally supplied.\n"
22482 "\n"
22483 ""},
22484 { "plClearOpts", _wrap_plClearOpts, METH_NOARGS, NULL},
22485 { "plResetOpts", _wrap_plResetOpts, METH_NOARGS, NULL},
22486 { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22487 { "plOptUsage", _wrap_plOptUsage, METH_NOARGS, NULL},
22488 { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_O, NULL},
22489 { "plGetCursor", _wrap_plGetCursor, METH_O, "\n"
22490 "Wait for graphics input event and translate to world coordinates.\n"
22491 "\n"
22492 "DESCRIPTION:\n"
22493 "\n"
22494 " Wait for graphics input event and translate to world coordinates.\n"
22495 " Returns 0 if no translation to world coordinates is possible.\n"
22496 "\n"
22497 " This function returns 1 on success and 0 if no translation to world\n"
22498 " coordinates is possible.\n"
22499 "\n"
22500 " Redacted form: plGetCursor(gin)\n"
22501 "\n"
22502 " This function is used in examples 1 and 20.\n"
22503 "\n"
22504 "\n"
22505 "\n"
22506 "SYNOPSIS:\n"
22507 "\n"
22508 "PLINT plGetCursor(gin)\n"
22509 "\n"
22510 "ARGUMENTS:\n"
22511 "\n"
22512 " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22513 " which will contain the output. The structure is not allocated by\n"
22514 " the routine and must exist before the function is called.\n"
22515 "\n"
22516 ""},
22517 { NULL, NULL, 0, NULL }
22518};
22519
22520
22521/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22522
22523static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22524static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22525static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22526static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22527static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
22528static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
22529static 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};
22530static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void = {"_p_f_int_double_p_char_int_p_void__void", "label_func|void (*)(int,double,char *,int,void *)", 0, 0, (void*)0, 0};
22531static 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};
22532static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void = {"_p_f_int_p_q_const__double_p_q_const__double__void", "fill_func|void (*)(int,double const *,double const *)", 0, 0, (void*)0, 0};
22533static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
22534static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22535static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22536static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
22537
22554
22555static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22556static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22557static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22558static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22559static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
22565static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22566static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
22567static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
22568static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22569
22586
22587
22588/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
22589
22591{0, 0, 0, 0.0, 0, 0}};
22592
22593#ifdef __cplusplus
22594}
22595#endif
22596/* -----------------------------------------------------------------------------
22597 * Type initialization:
22598 * This problem is tough by the requirement that no dynamic
22599 * memory is used. Also, since swig_type_info structures store pointers to
22600 * swig_cast_info structures and swig_cast_info structures store pointers back
22601 * to swig_type_info structures, we need some lookup code at initialization.
22602 * The idea is that swig generates all the structures that are needed.
22603 * The runtime then collects these partially filled structures.
22604 * The SWIG_InitializeModule function takes these initial arrays out of
22605 * swig_module, and does all the lookup, filling in the swig_module.types
22606 * array with the correct data and linking the correct swig_cast_info
22607 * structures together.
22608 *
22609 * The generated swig_type_info structures are assigned statically to an initial
22610 * array. We just loop through that array, and handle each type individually.
22611 * First we lookup if this type has been already loaded, and if so, use the
22612 * loaded structure instead of the generated one. Then we have to fill in the
22613 * cast linked list. The cast data is initially stored in something like a
22614 * two-dimensional array. Each row corresponds to a type (there are the same
22615 * number of rows as there are in the swig_type_initial array). Each entry in
22616 * a column is one of the swig_cast_info structures for that type.
22617 * The cast_initial array is actually an array of arrays, because each row has
22618 * a variable number of columns. So to actually build the cast linked list,
22619 * we find the array of casts associated with the type, and loop through it
22620 * adding the casts to the list. The one last trick we need to do is making
22621 * sure the type pointer in the swig_cast_info struct is correct.
22622 *
22623 * First off, we lookup the cast->type name to see if it is already loaded.
22624 * There are three cases to handle:
22625 * 1) If the cast->type has already been loaded AND the type we are adding
22626 * casting info to has not been loaded (it is in this module), THEN we
22627 * replace the cast->type pointer with the type pointer that has already
22628 * been loaded.
22629 * 2) If BOTH types (the one we are adding casting info to, and the
22630 * cast->type) are loaded, THEN the cast info has already been loaded by
22631 * the previous module so we just ignore it.
22632 * 3) Finally, if cast->type has not already been loaded, then we add that
22633 * swig_cast_info to the linked list (because the cast->type) pointer will
22634 * be correct.
22635 * ----------------------------------------------------------------------------- */
22636
22637#ifdef __cplusplus
22638extern "C" {
22639#if 0
22640} /* c-mode */
22641#endif
22642#endif
22643
22644#if 0
22645#define SWIGRUNTIME_DEBUG
22646#endif
22647
22648#ifndef SWIG_INIT_CLIENT_DATA_TYPE
22649#define SWIG_INIT_CLIENT_DATA_TYPE void *
22650#endif
22651
22652SWIGRUNTIME void
22654 size_t i;
22655 swig_module_info *module_head, *iter;
22656 int init;
22657
22658 /* check to see if the circular list has been setup, if not, set it up */
22659 if (swig_module.next==0) {
22660 /* Initialize the swig_module */
22661 swig_module.type_initial = swig_type_initial;
22662 swig_module.cast_initial = swig_cast_initial;
22663 swig_module.next = &swig_module;
22664 init = 1;
22665 } else {
22666 init = 0;
22667 }
22668
22669 /* Try and load any already created modules */
22670 module_head = SWIG_GetModule(clientdata);
22671 if (!module_head) {
22672 /* This is the first module loaded for this interpreter */
22673 /* so set the swig module into the interpreter */
22674 SWIG_SetModule(clientdata, &swig_module);
22675 } else {
22676 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
22677 iter=module_head;
22678 do {
22679 if (iter==&swig_module) {
22680 /* Our module is already in the list, so there's nothing more to do. */
22681 return;
22682 }
22683 iter=iter->next;
22684 } while (iter!= module_head);
22685
22686 /* otherwise we must add our module into the list */
22687 swig_module.next = module_head->next;
22688 module_head->next = &swig_module;
22689 }
22690
22691 /* When multiple interpreters are used, a module could have already been initialized in
22692 a different interpreter, but not yet have a pointer in this interpreter.
22693 In this case, we do not want to continue adding types... everything should be
22694 set up already */
22695 if (init == 0) return;
22696
22697 /* Now work on filling in swig_module.types */
22698#ifdef SWIGRUNTIME_DEBUG
22699 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
22700#endif
22701 for (i = 0; i < swig_module.size; ++i) {
22702 swig_type_info *type = 0;
22703 swig_type_info *ret;
22704 swig_cast_info *cast;
22705
22706#ifdef SWIGRUNTIME_DEBUG
22707 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
22708#endif
22709
22710 /* if there is another module already loaded */
22711 if (swig_module.next != &swig_module) {
22712 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
22713 }
22714 if (type) {
22715 /* Overwrite clientdata field */
22716#ifdef SWIGRUNTIME_DEBUG
22717 printf("SWIG_InitializeModule: found type %s\n", type->name);
22718#endif
22719 if (swig_module.type_initial[i]->clientdata) {
22720 type->clientdata = swig_module.type_initial[i]->clientdata;
22721#ifdef SWIGRUNTIME_DEBUG
22722 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
22723#endif
22724 }
22725 } else {
22726 type = swig_module.type_initial[i];
22727 }
22728
22729 /* Insert casting types */
22730 cast = swig_module.cast_initial[i];
22731 while (cast->type) {
22732 /* Don't need to add information already in the list */
22733 ret = 0;
22734#ifdef SWIGRUNTIME_DEBUG
22735 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
22736#endif
22737 if (swig_module.next != &swig_module) {
22739#ifdef SWIGRUNTIME_DEBUG
22740 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
22741#endif
22742 }
22743 if (ret) {
22744 if (type == swig_module.type_initial[i]) {
22745#ifdef SWIGRUNTIME_DEBUG
22746 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
22747#endif
22748 cast->type = ret;
22749 ret = 0;
22750 } else {
22751 /* Check for casting already in the list */
22752 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
22753#ifdef SWIGRUNTIME_DEBUG
22754 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
22755#endif
22756 if (!ocast) ret = 0;
22757 }
22758 }
22759
22760 if (!ret) {
22761#ifdef SWIGRUNTIME_DEBUG
22762 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
22763#endif
22764 if (type->cast) {
22765 type->cast->prev = cast;
22766 cast->next = type->cast;
22767 }
22768 type->cast = cast;
22769 }
22770 cast++;
22771 }
22772 /* Set entry in modules->types array equal to the type */
22773 swig_module.types[i] = type;
22774 }
22775 swig_module.types[i] = 0;
22776
22777#ifdef SWIGRUNTIME_DEBUG
22778 printf("**** SWIG_InitializeModule: Cast List ******\n");
22779 for (i = 0; i < swig_module.size; ++i) {
22780 int j = 0;
22781 swig_cast_info *cast = swig_module.cast_initial[i];
22782 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
22783 while (cast->type) {
22784 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
22785 cast++;
22786 ++j;
22787 }
22788 printf("---- Total casts: %d\n",j);
22789 }
22790 printf("**** SWIG_InitializeModule: Cast List ******\n");
22791#endif
22792}
22793
22794/* This function will propagate the clientdata field of type to
22795* any new swig_type_info structures that have been added into the list
22796* of equivalent types. It is like calling
22797* SWIG_TypeClientData(type, clientdata) a second time.
22798*/
22799SWIGRUNTIME void
22801 size_t i;
22802 swig_cast_info *equiv;
22803 static int init_run = 0;
22804
22805 if (init_run) return;
22806 init_run = 1;
22807
22808 for (i = 0; i < swig_module.size; i++) {
22809 if (swig_module.types[i]->clientdata) {
22810 equiv = swig_module.types[i]->cast;
22811 while (equiv) {
22812 if (!equiv->converter) {
22813 if (equiv->type && !equiv->type->clientdata)
22814 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
22815 }
22816 equiv = equiv->next;
22817 }
22818 }
22819 }
22820}
22821
22822#ifdef __cplusplus
22823#if 0
22824{
22825 /* c-mode */
22826#endif
22827}
22828#endif
22829
22830
22831
22832#ifdef __cplusplus
22833extern "C" {
22834#endif
22835
22836 /* -----------------------------------------------------------------------------
22837 * constants/methods manipulation
22838 * ----------------------------------------------------------------------------- */
22839
22840 /* Install Constants */
22841 SWIGINTERN void
22843 PyObject *obj = 0;
22844 size_t i;
22845 for (i = 0; constants[i].type; ++i) {
22846 switch(constants[i].type) {
22847 case SWIG_PY_POINTER:
22848 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
22849 break;
22850 case SWIG_PY_BINARY:
22851 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
22852 break;
22853 default:
22854 obj = 0;
22855 break;
22856 }
22857 if (obj) {
22858 PyDict_SetItemString(d, constants[i].name, obj);
22859 Py_DECREF(obj);
22860 }
22861 }
22862 }
22863
22864 /* -----------------------------------------------------------------------------
22865 * Patch %callback methods' docstrings to hold the callback ptrs
22866 * -----------------------------------------------------------------------------*/
22867
22868 SWIGINTERN void
22869 SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
22870 size_t i;
22871 for (i = 0; methods[i].ml_name; ++i) {
22872 const char *c = methods[i].ml_doc;
22873 if (!c) continue;
22874 c = strstr(c, "swig_ptr: ");
22875 if (c) {
22876 int j;
22877 const swig_const_info *ci = 0;
22878 const char *name = c + 10;
22879 for (j = 0; const_table[j].type; ++j) {
22880 if (strncmp(const_table[j].name, name,
22881 strlen(const_table[j].name)) == 0) {
22882 ci = &(const_table[j]);
22883 break;
22884 }
22885 }
22886 if (ci) {
22887 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
22888 if (ptr) {
22889 size_t shift = (ci->ptype) - types;
22890 swig_type_info *ty = types_initial[shift];
22891 size_t ldoc = (c - methods[i].ml_doc);
22892 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
22893 char *ndoc = (char*)malloc(ldoc + lptr + 10);
22894 if (ndoc) {
22895 char *buff = ndoc;
22896 memcpy(buff, methods[i].ml_doc, ldoc);
22897 buff += ldoc;
22898 memcpy(buff, "swig_ptr: ", 10);
22899 buff += 10;
22900 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
22901 methods[i].ml_doc = ndoc;
22902 }
22903 }
22904 }
22905 }
22906 }
22907 }
22908
22909#ifdef __cplusplus
22910}
22911#endif
22912
22913
22914
22915
22916/* -----------------------------------------------------------------------------*
22917 * Partial Init method
22918 * -----------------------------------------------------------------------------*/
22919
22920#ifdef __cplusplus
22921extern "C"
22922#endif
22923
22925#if PY_VERSION_HEX >= 0x03000000
22926PyObject*
22927#else
22928void
22929#endif
22931 PyObject *m, *d, *md, *globals;
22932
22933#if PY_VERSION_HEX >= 0x03000000
22934 static struct PyModuleDef SWIG_module = {
22935 PyModuleDef_HEAD_INIT,
22936 SWIG_name,
22937 NULL,
22938 -1,
22940 NULL,
22941 NULL,
22942 NULL,
22943 NULL
22944 };
22945#endif
22946
22947#if defined(SWIGPYTHON_BUILTIN)
22948 static SwigPyClientData SwigPyObject_clientdata = {
22949 0, 0, 0, 0, 0, 0, 0
22950 };
22951 static PyGetSetDef this_getset_def = {
22952 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
22953 };
22954 static SwigPyGetSet thisown_getset_closure = {
22957 };
22958 static PyGetSetDef thisown_getset_def = {
22959 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
22960 };
22961 PyTypeObject *builtin_pytype;
22962 int builtin_base_count;
22963 swig_type_info *builtin_basetype;
22964 PyObject *tuple;
22965 PyGetSetDescrObject *static_getset;
22966 PyTypeObject *metatype;
22967 PyTypeObject *swigpyobject;
22968 SwigPyClientData *cd;
22969 PyObject *public_interface, *public_symbol;
22970 PyObject *this_descr;
22971 PyObject *thisown_descr;
22972 PyObject *self = 0;
22973 int i;
22974
22975 (void)builtin_pytype;
22976 (void)builtin_base_count;
22977 (void)builtin_basetype;
22978 (void)tuple;
22979 (void)static_getset;
22980 (void)self;
22981
22982 /* Metaclass is used to implement static member variables */
22983 metatype = SwigPyObjectType();
22984 assert(metatype);
22985#endif
22986
22987 (void)globals;
22988
22989 /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
22990 SWIG_This();
22993#ifndef SWIGPYTHON_BUILTIN
22995#endif
22996
22997 /* Fix SwigMethods to carry the callback ptrs when needed */
22999
23000#if PY_VERSION_HEX >= 0x03000000
23001 m = PyModule_Create(&SWIG_module);
23002#else
23003 m = Py_InitModule(SWIG_name, SwigMethods);
23004#endif
23005
23006 md = d = PyModule_GetDict(m);
23007 (void)md;
23008
23010
23011#ifdef SWIGPYTHON_BUILTIN
23012 swigpyobject = SwigPyObject_TypeOnce();
23013
23014 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23015 assert(SwigPyObject_stype);
23016 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23017 if (!cd) {
23018 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23019 SwigPyObject_clientdata.pytype = swigpyobject;
23020 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
23021 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23022# if PY_VERSION_HEX >= 0x03000000
23023 return NULL;
23024# else
23025 return;
23026# endif
23027 }
23028
23029 /* All objects have a 'this' attribute */
23030 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23031 (void)this_descr;
23032
23033 /* All objects have a 'thisown' attribute */
23034 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23035 (void)thisown_descr;
23036
23037 public_interface = PyList_New(0);
23038 public_symbol = 0;
23039 (void)public_symbol;
23040
23041 PyDict_SetItemString(md, "__all__", public_interface);
23042 Py_DECREF(public_interface);
23043 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23044 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23045 for (i = 0; swig_const_table[i].name != 0; ++i)
23046 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23047#endif
23048
23050
23051
23052 import_array();
23053
23054 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23055 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23056 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23057 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23058 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23059 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23060 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23061 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23062 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23063 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23064 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23065 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23066 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23067 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23068 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23069 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23070 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23071 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23072 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23073 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23074 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23075 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23076 SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23077 SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23078 SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23079 SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23080 SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23081 SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23082 SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23083 SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23084 SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23085 SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23086 SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23087 SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23088 SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23089 SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23090 SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23091 SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23092 SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23093 SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23094 SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23095 SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23096 SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23097 SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23098 SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23099 SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23100 SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23101 SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23102 SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23103 SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23104 SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23105 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23106 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23107 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23108 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23109 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23110 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23111 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23112 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23113 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23114 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23115 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23116 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23117 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23118 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23119 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23120 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23121 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23122 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23123 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23124 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23125 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23126 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23127 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23128 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23129 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23130 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23131 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23132 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23133 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23134 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23135 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23136 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23137 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23138 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23139 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23140 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23141 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23142 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23143 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23144 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23145 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23146 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23147 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23148 SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23149 SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23150 SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23151 SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23152 SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23153 SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23154 SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23155 SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23156 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23157 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23158 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23159 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23160 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23161 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23162 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23163 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL0",SWIG_From_int((int)(16)));
23164 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL1",SWIG_From_int((int)(128)));
23165 SWIG_Python_SetConstant(d, "MIN_PLINT_RGB",SWIG_From_int((int)(0)));
23166 SWIG_Python_SetConstant(d, "MAX_PLINT_RGB",SWIG_From_int((int)(255)));
23167 SWIG_Python_SetConstant(d, "MIN_PLFLT_CMAP1",SWIG_From_double((double)(0.)));
23168 SWIG_Python_SetConstant(d, "MAX_PLFLT_CMAP1",SWIG_From_double((double)(1.)));
23169 SWIG_Python_SetConstant(d, "MIN_PLFLT_ALPHA",SWIG_From_double((double)(0.)));
23170 SWIG_Python_SetConstant(d, "MAX_PLFLT_ALPHA",SWIG_From_double((double)(1.)));
23171 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23172 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23173 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23174 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23175 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23176 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23177 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23178 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23179 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23180 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23181 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23182 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23183 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23184 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23185 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23186 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23187 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23188 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23189 SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23190 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23191 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23192 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23193 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23194 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23195 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23196 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23197 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23198 SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23199 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23200 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23201 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23202 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23203 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23204 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23205 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23206 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23207 SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23208 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23209 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23210 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23211 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23212 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23213 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23214 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23215 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23216 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23217 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23218 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23219 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23220 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23221 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23222 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23223 SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23224 SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23225 SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23226 SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23227 SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23228 SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23229 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23230 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23231 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23232 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23233 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23234 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23235 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23236 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23237 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23238 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23239#if PY_VERSION_HEX >= 0x03000000
23240 return m;
23241#else
23242 return;
23243#endif
23244}
23245
#define min(x, y)
Definition nnpi.c:87
#define max(x, y)
Definition nnpi.c:88
void plOptUsage(void)
Definition plargs.c:1304
void plClearOpts(void)
Definition plargs.c:830
void plResetOpts(void)
Definition plargs.c:843
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition plargs.c:1287
static int error
Definition plcont.c:61
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:941
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:874
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition plcont.c:858
void plsxwin(PLINT window_id)
Definition plcore.c:3978
static PLFLT value(double n1, double n2, double hue)
Definition plctrl.c:1219
void plMinMax2dGrid(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLFLT *fnmax, PLFLT *fnmin)
Definition plmem.c:141
PLINT plGetCursor(PLGraphicsIn *plg)
Definition plpage.c:244
#define plgfci
Definition plplot.h:735
#define plgstrm
Definition plplot.h:744
#define plpat
Definition plplot.h:779
#define plschr
Definition plplot.h:790
#define plfontld
Definition plplot.h:721
#define plpath
Definition plplot.h:761
#define plerry
Definition plplot.h:715
#define plsfam
Definition plplot.h:816
#define plsmaj
Definition plplot.h:826
#define plsmin
Definition plplot.h:829
#define pleop
Definition plplot.h:713
#define plimage
Definition plplot.h:753
#define plstransform
Definition plplot.h:840
#define plmap
Definition plplot.h:764
#define plfill
Definition plplot.h:717
#define plvpas
Definition plplot.h:859
#define plgdiplt
Definition plplot.h:732
#define plerrx
Definition plplot.h:714
#define plinit
Definition plplot.h:755
#define plscmap1l
Definition plplot.h:796
#define plsori
Definition plplot.h:830
#define plbox3
Definition plplot.h:698
#define plmapfill
Definition plplot.h:768
#define plcol1
Definition plplot.h:703
#define pltimefmt
Definition plplot.h:856
PLUINT PLUNICODE
Definition plplot.h:201
#define plmaptex
Definition plplot.h:767
#define plvect
Definition plplot.h:858
#define plgchr
Definition plplot.h:722
float PLFLT
Definition plplot.h:163
#define pllegend
Definition plplot.h:758
#define plsyax
Definition plplot.h:852
#define plgver
Definition plplot.h:745
#define plscolbg
Definition plplot.h:802
#define plpsty
Definition plplot.h:784
#define plgfont
Definition plplot.h:737
#define plenv
Definition plplot.h:711
#define pllightsource
Definition plplot.h:759
#define plsmema
Definition plplot.h:828
#define plpoin3
Definition plplot.h:781
#define plgspa
Definition plplot.h:743
#define plscol0
Definition plplot.h:800
#define plptex
Definition plplot.h:785
#define plrgbhls
Definition plplot.h:789
#define plbop
Definition plplot.h:696
#define plgdidev
Definition plplot.h:730
#define plpoin
Definition plplot.h:780
#define plptex3
Definition plplot.h:786
#define plstripd
Definition plplot.h:845
#define plhist
Definition plplot.h:751
#define plmapline
Definition plplot.h:765
#define plgfnam
Definition plplot.h:736
#define plgdiori
Definition plplot.h:731
#define plszax
Definition plplot.h:854
#define plsmem
Definition plplot.h:827
#define plstripa
Definition plplot.h:843
#define plgxax
Definition plplot.h:748
#define plgra
Definition plplot.h:740
#define plenv0
Definition plplot.h:712
#define plspal1
Definition plplot.h:833
#define plstring3
Definition plplot.h:842
#define plxormod
Definition plplot.h:865
#define plspause
Definition plplot.h:834
#define plgdev
Definition plplot.h:729
#define plgradient
Definition plplot.h:741
#define plspal0
Definition plplot.h:832
#define plcalc_world
Definition plplot.h:700
#define plwidth
Definition plplot.h:863
#define pllab
Definition plplot.h:757
#define plsurf3d
Definition plplot.h:847
#define plsurf3dl
Definition plplot.h:848
#define plvasp
Definition plplot.h:857
#define plscmap0n
Definition plplot.h:793
#define plmtex3
Definition plplot.h:774
#define plctime
Definition plplot.h:708
#define plclear
Definition plplot.h:701
#define plsvpa
Definition plplot.h:850
#define plw3d
Definition plplot.h:862
#define plot3dcl
Definition plplot.h:777
#define plscmap1n
Definition plplot.h:798
#define plgvpd
Definition plplot.h:746
#define plhlsrgb
Definition plplot.h:752
#define pl_setcontlabelformat
Definition plplot.h:690
#define plsdev
Definition plplot.h:806
#define plconfigtime
Definition plplot.h:705
#define plscolbga
Definition plplot.h:803
#define PL_UNUSED(x)
Definition plplot.h:138
#define plscmap1
Definition plplot.h:794
#define plsdiplz
Definition plplot.h:811
#define plparseopts
Definition plplot.h:778
#define plmapstring
Definition plplot.h:766
#define plot3d
Definition plplot.h:775
#define plsesc
Definition plplot.h:814
#define plarc
Definition plplot.h:693
#define plsetopt
Definition plplot.h:815
#define plgvpw
Definition plplot.h:747
#define pltext
Definition plplot.h:855
#define plstring
Definition plplot.h:841
#define plsdiori
Definition plplot.h:809
#define plcont
Definition plplot.h:706
#define plspage
Definition plplot.h:831
#define plaxes
Definition plplot.h:694
#define pllsty
Definition plplot.h:763
#define plslabelfunc
Definition plplot.h:825
#define plshades
Definition plplot.h:824
#define plglevel
Definition plplot.h:738
#define plscompression
Definition plplot.h:805
#define plfamadv
Definition plplot.h:716
#define plfont
Definition plplot.h:720
#define plscmap0a
Definition plplot.h:792
#define plgcol0a
Definition plplot.h:725
#define plscmap1_range
Definition plplot.h:799
#define plmeshc
Definition plplot.h:771
#define plshade
Definition plplot.h:820
#define plsym
Definition plplot.h:853
#define plscmap1a
Definition plplot.h:795
#define plscmap0
Definition plplot.h:791
#define plgriddata
Definition plplot.h:742
#define plstripc
Definition plplot.h:844
#define pl_setcontlabelparam
Definition plplot.h:691
#define plsvect
Definition plplot.h:849
#define plstyl
Definition plplot.h:846
#define plline
Definition plplot.h:760
#define pljoin
Definition plplot.h:756
#define plgzax
Definition plplot.h:750
#define plsstrm
Definition plplot.h:835
#define plscmap1la
Definition plplot.h:797
#define plssym
Definition plplot.h:837
#define plscolor
Definition plplot.h:804
#define plcol0
Definition plplot.h:702
#define plsdiplt
Definition plplot.h:810
#define plcolorbar
Definition plplot.h:704
#define plvsta
Definition plplot.h:861
#define plmeridians
Definition plplot.h:769
#define plot3dc
Definition plplot.h:776
#define plcpstrm
Definition plplot.h:707
#define plmkstrm
Definition plplot.h:772
#define plgcol0
Definition plplot.h:724
#define pladv
Definition plplot.h:692
#define plgcolbga
Definition plplot.h:727
#define plline3
Definition plplot.h:762
#define plprec
Definition plplot.h:783
#define plfill3
Definition plplot.h:718
#define plseed
Definition plplot.h:813
#define plgcompression
Definition plplot.h:728
#define plimagefr
Definition plplot.h:754
#define plsfont
Definition plplot.h:819
int PLINT
Definition plplot.h:181
#define plgfam
Definition plplot.h:734
#define plscol0a
Definition plplot.h:801
#define plend1
Definition plplot.h:710
#define plrandd
Definition plplot.h:787
#define plbin
Definition plplot.h:695
#define plsdidev
Definition plplot.h:807
#define plsfnam
Definition plplot.h:818
void * PLPointer
Definition plplot.h:209
#define plflush
Definition plplot.h:719
#define plwind
Definition plplot.h:864
#define plstar
Definition plplot.h:838
#define plmtex
Definition plplot.h:773
PLINT PLBOOL
Definition plplot.h:204
#define plsdimap
Definition plplot.h:808
#define plsfci
Definition plplot.h:817
#define plend
Definition plplot.h:709
#define plmesh
Definition plplot.h:770
#define plreplot
Definition plplot.h:788
#define plgcolbg
Definition plplot.h:726
#define plgcmap1_range
Definition plplot.h:723
#define plstart
Definition plplot.h:839
#define plsxax
Definition plplot.h:851
#define plbox
Definition plplot.h:697
#define plbtime
Definition plplot.h:699
#define plgyax
Definition plplot.h:749
#define plvpor
Definition plplot.h:860
#define plpoly3
Definition plplot.h:782
#define plgpage
Definition plplot.h:739
#define plssub
Definition plplot.h:836
SWIGINTERN PyObject * _wrap_plstransform(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *self, PyObject *args)
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *self, PyObject *args)
static swig_cast_info * swig_cast_initial[]
SWIGINTERN int swig_varlink_setattr(PyObject *o, char *n, PyObject *p)
SWIGINTERN PyObject * _wrap_plgra(PyObject *self, PyObject *args)
static int interpreter_counter
static PLcGrid2 tmpGrid2
SWIGINTERN PyObject * _wrap_plvpas(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *self, PyObject *args)
#define SWIG_MangledTypeQuery(name)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args)
static PLcGrid tmpGrid1
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *self, PyObject *args)
static PyObject * Swig_This_global
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
static swig_cast_info _swigc__p_PLcGrid2[]
SWIGINTERN PyObject * _wrap_plerrx(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *self, PyObject *args)
SWIGINTERN Py_ssize_t SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
#define SWIG_TypeQuery(name)
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *self, PyObject *args)
#define SWIG_POINTER_OWN
SWIGINTERN PyObject * _wrap_plfill3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args)
#define SWIG_SyntaxError
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *self, PyObject *args)
#define SWIG_POINTER_NEW
SWIGINTERN PyObject * _wrap_plgfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *self, PyObject *args)
#define SWIG_CheckState(r)
static swig_cast_info _swigc__p_f_double_double__int[]
void cleanup_mapform(void)
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_int[]
SWIGINTERN PyObject * _wrap_plschr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstart(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args)
#define SWIG_BUFFER_SIZE
#define SWIG_TypeError
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
pltr_func marshal_pltr(PyObject *input)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args)
static PLINT Alen
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args)
#define myArray_ContiguousFromObject
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plend(PyObject *self, PyObject *args)
#define SWIG_POINTER_IMPLICIT_CONV
static swig_cast_info _swigc__p_double[]
#define SWIGTYPE_p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *self, PyObject *args)
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plbin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *self, PyObject *args)
#define SWIG_PY_POINTER
struct swig_cast_info swig_cast_info
SWIGINTERN PyObject * _wrap_plpoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *self, PyObject *args)
#define SWIG_init
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
#define SWIG_PYTHON_THREAD_END_BLOCK
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *self, PyObject *args)
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *self, PyObject *args)
#define SWIG_RuntimeError
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
SWIGINTERN PyObject * _wrap_pladv(PyObject *self, PyObject *args)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *self, PyObject *args)
#define SWIGPY_CAPSULE_ATTR_NAME
SWIGINTERN PyObject * _wrap_plsfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmema(PyObject *self, PyObject *args)
struct swig_varlinkobject swig_varlinkobject
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *self, PyObject *args)
#define SWIG_NewClientData(obj)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *self, PyObject *args)
mapform_func marshal_mapform(PyObject *input)
#define PyObject_DEL
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGINTERN PyObject * _wrap_plline(PyObject *self, PyObject *args)
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *self, PyObject *args)
#define SWIGRUNTIME
SWIGINTERN PyObject * _wrap_plvasp(PyObject *self, PyObject *args)
#define SWIG_PY_BINARY
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *self, PyObject *args)
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *self, PyObject *args)
PyObject * python_f2eval
SWIGINTERN char * SWIG_Python_str_AsChar(PyObject *str)
SWIGINTERN PyObject * _wrap_plscolor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
SWIGINTERN PyObject * _wrap_plssym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *self, PyObject *args)
#define SWIG_POINTER_NOSHADOW
SWIGINTERN PyObject * _wrap_plwind(PyObject *self, PyObject *args)
#define SWIG_OLDOBJ
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
#define SWIG_ValueError
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGINTERN PyObject * _wrap_plend1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *self, PyObject *args)
#define t_output_helper
SWIGINTERN PyObject * _wrap_plsmin(PyObject *self, PyObject *args)
static PyMethodDef swigobject_methods[]
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *self, PyObject *args)
#define SWIG_AddCast(r)
void cleanup_PLcGrid1(void)
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
#define SWIG_IsNewObj(r)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *self, PyObject *args)
#define SWIG_InternalNewPointerObj(ptr, type, flags)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *self, PyObject *args)
#define NPY_PLFLT
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
#define SWIG_exception_fail(code, msg)
void cleanup_ct(void)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltr2(PyObject *self, PyObject *args)
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args)
#define SWIG_AttributeError
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args)
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args)
static swig_module_info swig_module
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *self, PyObject *args)
static PLINT Ylen
SWIGINTERN PyObject * _wrap_pltr1(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_double
SWIGINTERN PyObject * _wrap_plgdev(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_TypeErrorOccurred(PyObject *obj)
SWIGRUNTIME void SWIG_Python_DestroyModule(PyObject *obj)
#define SWIG_SetModule(clientdata, pointer)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *self, PyObject *args)
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
SWIGINTERN PyObject * swig_varlink_str(PyObject *o)
SWIGINTERN PyTypeObject * swig_varlink_type(void)
SWIGINTERN PyObject * _wrap_pllab(PyObject *self, PyObject *args)
#define SWIG_INIT_CLIENT_DATA_TYPE
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *self, PyObject *args)
#define SWIGUNUSEDPARM(p)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *self, PyObject *args)
PLPointer marshal_PLPointer(PyObject *input, int isimg)
#define SWIG_POINTER_RELEASE
SWIGINTERN PyObject * _wrap_plstring3(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define SWIG_as_voidptr(a)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
static swig_const_info swig_const_table[]
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plscol0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
static swig_type_info _swigt__p_p_char
#define SWIG_Python_CallFunctor(functor, obj)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
static swig_type_info _swigt__p_p_double
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *self, PyObject *args)
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
#define SWIG_POINTER_CLEAR
PyObject * python_label
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
#define SWIGTYPE_p_int
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
struct swig_const_info swig_const_info
SWIGINTERN PyObject * _wrap_plpsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plimage(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *self, PyObject *args)
static PyObject * Swig_Globals_global
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *self, PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *self, PyObject *args)
#define SWIG_newvarlink()
SWIGRUNTIME void SWIG_Python_RaiseOrModifyTypeError(const char *message)
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
PLINT(* defined_func)(PLFLT, PLFLT)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *self, PyObject *args)
void cleanup_pltr(void)
void cleanup_PLcGrid2(void)
static PyObject * Swig_TypeCache_global
SWIGINTERN PyObject * _wrap_plglevel(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_p_double[]
#define SWIGINTERN
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
SWIGINTERN PyObject * _wrap_plpath(PyObject *self, PyObject *args)
#define SWIG_From_double
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
struct swig_globalvar swig_globalvar
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
#define SWIGPY_CAPSULE_NAME
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
#define SWIG_ArgError(r)
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
PyObject * python_pltr
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
#define SWIG_NewPointerObj(ptr, type, flags)
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *self, PyObject *args)
ct_func marshal_ct(PyObject *input)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *self, PyObject *args)
#define SWIG_POINTER_NO_NULL
#define SWIG_Python_str_FromFormat
#define SWIG_InstallConstants(d, constants)
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *self, PyObject *args)
#define SWIG_IOError
static PyMethodDef SwigMethods[]
#define SWIG_NullReferenceError
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_pleop(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
#define SWIG_POINTER_DISOWN
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args)
#define SWIG_STATIC_POINTER(var)
struct swig_type_info swig_type_info
PyObject * python_mapform
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v))
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
static swig_type_info _swigt__p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plflush(PyObject *self, PyObject *args)
#define SWIG_IsTmpObj(r)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_f_double_double__int
SWIGINTERN PyObject * _wrap_plcont(PyObject *self, PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
SWIGINTERN PyObject * _wrap_plsori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plbop(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
#define SWIG_NEWOBJ
#define MY_BLOCK_THREADS
SWIGINTERN PyObject * _wrap_plgver(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *self, PyObject *args)
#define SWIG_TMPOBJ
SWIGINTERN PyObject * _wrap_pllsty(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
#define SWIG_DelNewMask(r)
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *self, PyObject *args)
#define SWIG_NewPackedObj(ptr, sz, type)
static swig_cast_info _swigc__p_PLcGrid[]
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *self, PyObject *args)
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
#define SWIG_GetModule(clientdata)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_unsigned_int[]
#define SWIG_fail
static swig_type_info _swigt__p_int
SWIGINTERN PyObject * PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *self, PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty)
SWIGRUNTIME void SWIG_PropagateClientData(void)
PyArrayObject * pltr_xg
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
#define NPY_PLINT
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
SWIGINTERN PyObject * _wrap_plsmem(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *self, PyObject *args)
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
#define SWIG_ERROR_RELEASE_NOT_OWNED
SWIGRUNTIME PyObject * SWIG_This(void)
SWIGINTERN PyObject * _wrap_plenv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_PLcGrid
#define SWIG_BUILTIN_TP_INIT
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
SWIGINTERN void swig_varlink_dealloc(PyObject *o)
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v)
static PLINT Xlen
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
SWIGINTERN PyObject * _wrap_plfont(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *self, PyObject *args)
PyArrayObject * pltr_yg
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args)
struct swig_module_info swig_module_info
PyObject * python_ct
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
#define SWIG_ERROR
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
#define SWIG_name
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *self, PyObject *args)
static swig_type_info * swig_type_initial[]
SWIGINTERN PyObject * _wrap_plerry(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *self, PyObject *args)
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
#define PySequence_Fast_GET_ITEM
SWIGINTERN PyObject * _wrap_plmap(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
SWIGINTERN PyObject * _wrap_plhist(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGINTERN PyObject * _wrap_pltr0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *self, PyObject *args)
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_getattr(PyObject *o, char *n)
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args)
#define PySequence_Size
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *self, PyObject *args)
#define SWIG_MemoryError
SWIGINTERN PyObject * _wrap_plfontld(PyObject *self, PyObject *args)
#define SWIG_SystemError
#define SWIG_DivisionByZero
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args)
#define SWIGTYPE_p_double
static swig_type_info _swigt__p_char
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
#define SWIG_OverflowError
#define SWIGEXPORT
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
#define SWIG_IsOK(r)
SWIGINTERN PyObject * _wrap_plstring(PyObject *self, PyObject *args)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
static PyObject * Swig_Capsule_global
static swig_type_info _swigt__p_PLcGrid2
SWIGINTERN PyObject * _wrap_plctime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *self, PyObject *args)
#define SWIG_IndexError
SWIGINTERN PyObject * _wrap_plspal0(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
static swig_type_info * swig_types[15]
SWIGRUNTIME PyObject * SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *self, PyObject *args)
#define SWIG_AddNewMask(r)
SWIGINTERN PyObject * SWIG_globals(void)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *self, PyObject *args)
#define SWIG_OK
SWIGINTERN PyObject * _wrap_plbox(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args)
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#define SWIGINTERNINLINE
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *self, PyObject *args)
enum callback_type pltr_type
SWIGINTERN PyObject * _wrap_plaxes(PyObject *self, PyObject *args)
#define Py_TYPE(op)
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
#define MY_UNBLOCK_THREADS
#define SWIGRUNTIMEINLINE
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
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