PLplot 5.15.0
Loading...
Searching...
No Matches
plplotcPYTHON_wrap.c
Go to the documentation of this file.
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (https://www.swig.org).
3 * Version 4.2.1
4 *
5 * Do not make changes to this file unless you know what you are doing - modify
6 * the SWIG interface file instead.
7 * ----------------------------------------------------------------------------- */
8
9
10#define SWIG_VERSION 0x040201
11#define SWIGPYTHON
12#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14/* -----------------------------------------------------------------------------
15 * This section contains generic SWIG labels for method/variable
16 * declarations/attributes, and other compiler dependent labels.
17 * ----------------------------------------------------------------------------- */
18
19/* template workaround for compilers that cannot correctly implement the C++ standard */
20#ifndef SWIGTEMPLATEDISAMBIGUATOR
21# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
22# define SWIGTEMPLATEDISAMBIGUATOR template
23# elif defined(__HP_aCC)
24/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
25/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
26# define SWIGTEMPLATEDISAMBIGUATOR template
27# else
28# define SWIGTEMPLATEDISAMBIGUATOR
29# endif
30#endif
31
32/* inline attribute */
33#ifndef SWIGINLINE
34# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
35# define SWIGINLINE inline
36# else
37# define SWIGINLINE
38# endif
39#endif
40
41/* attribute recognised by some compilers to avoid 'unused' warnings */
42#ifndef SWIGUNUSED
43# if defined(__GNUC__)
44# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
45# define SWIGUNUSED __attribute__ ((__unused__))
46# else
47# define SWIGUNUSED
48# endif
49# elif defined(__ICC)
50# define SWIGUNUSED __attribute__ ((__unused__))
51# else
52# define SWIGUNUSED
53# endif
54#endif
55
56#ifndef SWIG_MSC_UNSUPPRESS_4505
57# if defined(_MSC_VER)
58# pragma warning(disable : 4505) /* unreferenced local function has been removed */
59# endif
60#endif
61
62#ifndef SWIGUNUSEDPARM
63# ifdef __cplusplus
64# define SWIGUNUSEDPARM(p)
65# else
66# define SWIGUNUSEDPARM(p) p SWIGUNUSED
67# endif
68#endif
69
70/* internal SWIG method */
71#ifndef SWIGINTERN
72# define SWIGINTERN static SWIGUNUSED
73#endif
74
75/* internal inline SWIG method */
76#ifndef SWIGINTERNINLINE
77# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
78#endif
79
80/* exporting methods */
81#if defined(__GNUC__)
82# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
83# ifndef GCC_HASCLASSVISIBILITY
84# define GCC_HASCLASSVISIBILITY
85# endif
86# endif
87#endif
88
89#ifndef SWIGEXPORT
90# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
91# if defined(STATIC_LINKED)
92# define SWIGEXPORT
93# else
94# define SWIGEXPORT __declspec(dllexport)
95# endif
96# else
97# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
98# define SWIGEXPORT __attribute__ ((visibility("default")))
99# else
100# define SWIGEXPORT
101# endif
102# endif
103#endif
104
105/* calling conventions for Windows */
106#ifndef SWIGSTDCALL
107# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
108# define SWIGSTDCALL __stdcall
109# else
110# define SWIGSTDCALL
111# endif
112#endif
113
114/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
115#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
116# define _CRT_SECURE_NO_DEPRECATE
117#endif
118
119/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
120#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
121# define _SCL_SECURE_NO_DEPRECATE
122#endif
123
124/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
125#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
126# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
127#endif
128
129/* Intel's compiler complains if a variable which was never initialised is
130 * cast to void, which is a common idiom which we use to indicate that we
131 * are aware a variable isn't used. So we just silence that warning.
132 * See: https://github.com/swig/swig/issues/192 for more discussion.
133 */
134#ifdef __INTEL_COMPILER
135# pragma warning disable 592
136#endif
137
138#if defined(__cplusplus) && __cplusplus >=201103L
139# define SWIG_NULLPTR nullptr
140#else
141# define SWIG_NULLPTR NULL
142#endif
143
144/* -----------------------------------------------------------------------------
145 * swigcompat.swg
146 *
147 * Macros to provide support compatibility with older C and C++ standards.
148 * ----------------------------------------------------------------------------- */
149
150/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
151 * if you're missing it.
152 */
153#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
154 (defined __cplusplus && __cplusplus >= 201103L) || \
155 defined SWIG_HAVE_SNPRINTF) && \
156 !defined SWIG_NO_SNPRINTF
157# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
158# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
159#else
160/* Fallback versions ignore the buffer size, but most of our uses either have a
161 * fixed maximum possible size or dynamically allocate a buffer that's large
162 * enough.
163 */
164# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
165# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
166#endif
167
168
169#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
170/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
171# include <math.h>
172#endif
173
174#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
175#define PY_SSIZE_T_CLEAN
176#endif
177
178#if __GNUC__ >= 7
179#pragma GCC diagnostic push
180#if defined(__cplusplus) && __cplusplus >=201703L
181#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
182#endif
183#endif
184
185#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
186/* Use debug wrappers with the Python release dll */
187
188#if defined(_MSC_VER) && _MSC_VER >= 1929
189/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
190 * See https://github.com/swig/swig/issues/2090 */
191# include <corecrt.h>
192#endif
193
194# undef _DEBUG
195# include <Python.h>
196# define _DEBUG 1
197#else
198# include <Python.h>
199#endif
200
201#if __GNUC__ >= 7
202#pragma GCC diagnostic pop
203#endif
204
205#include <stdio.h>
206
207/* -----------------------------------------------------------------------------
208 * swigrun.swg
209 *
210 * This file contains generic C API SWIG runtime support for pointer
211 * type checking.
212 * ----------------------------------------------------------------------------- */
213
214/* This should only be incremented when either the layout of swig_type_info changes,
215 or for whatever reason, the runtime changes incompatibly */
216#define SWIG_RUNTIME_VERSION "4"
217
218/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
219#ifdef SWIG_TYPE_TABLE
220# define SWIG_QUOTE_STRING(x) #x
221# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
222# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
223#else
224# define SWIG_TYPE_TABLE_NAME
225#endif
226
227/*
228 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
229 creating a static or dynamic library from the SWIG runtime code.
230 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
231
232 But only do this if strictly necessary, ie, if you have problems
233 with your compiler or suchlike.
234*/
235
236#ifndef SWIGRUNTIME
237# define SWIGRUNTIME SWIGINTERN
238#endif
239
240#ifndef SWIGRUNTIMEINLINE
241# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
242#endif
243
244/* Generic buffer size */
245#ifndef SWIG_BUFFER_SIZE
246# define SWIG_BUFFER_SIZE 1024
247#endif
248
249/* Flags for pointer conversions */
250#define SWIG_POINTER_DISOWN 0x1
251#define SWIG_CAST_NEW_MEMORY 0x2
252#define SWIG_POINTER_NO_NULL 0x4
253#define SWIG_POINTER_CLEAR 0x8
254#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
255
256/* Flags for new pointer objects */
257#define SWIG_POINTER_OWN 0x1
258
259
260/*
261 Flags/methods for returning states.
262
263 The SWIG conversion methods, as ConvertPtr, return an integer
264 that tells if the conversion was successful or not. And if not,
265 an error code can be returned (see swigerrors.swg for the codes).
266
267 Use the following macros/flags to set or process the returning
268 states.
269
270 In old versions of SWIG, code such as the following was usually written:
271
272 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
273 // success code
274 } else {
275 //fail code
276 }
277
278 Now you can be more explicit:
279
280 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
281 if (SWIG_IsOK(res)) {
282 // success code
283 } else {
284 // fail code
285 }
286
287 which is the same really, but now you can also do
288
289 Type *ptr;
290 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
291 if (SWIG_IsOK(res)) {
292 // success code
293 if (SWIG_IsNewObj(res) {
294 ...
295 delete *ptr;
296 } else {
297 ...
298 }
299 } else {
300 // fail code
301 }
302
303 I.e., now SWIG_ConvertPtr can return new objects and you can
304 identify the case and take care of the deallocation. Of course that
305 also requires SWIG_ConvertPtr to return new result values, such as
306
307 int SWIG_ConvertPtr(obj, ptr,...) {
308 if (<obj is ok>) {
309 if (<need new object>) {
310 *ptr = <ptr to new allocated object>;
311 return SWIG_NEWOBJ;
312 } else {
313 *ptr = <ptr to old object>;
314 return SWIG_OLDOBJ;
315 }
316 } else {
317 return SWIG_BADOBJ;
318 }
319 }
320
321 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
322 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
323 SWIG errors code.
324
325 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
326 allows returning the 'cast rank', for example, if you have this
327
328 int food(double)
329 int fooi(int);
330
331 and you call
332
333 food(1) // cast rank '1' (1 -> 1.0)
334 fooi(1) // cast rank '0'
335
336 just use the SWIG_AddCast()/SWIG_CheckState()
337*/
338
339#define SWIG_OK (0)
340/* Runtime errors are < 0 */
341#define SWIG_ERROR (-1)
342/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
343/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
344/* Errors < -200 are generic runtime specific errors */
345#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
346
347#define SWIG_IsOK(r) (r >= 0)
348#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
349
350/* The CastRankLimit says how many bits are used for the cast rank */
351#define SWIG_CASTRANKLIMIT (1 << 8)
352/* The NewMask denotes the object was created (using new/malloc) */
353#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
354/* The TmpMask is for in/out typemaps that use temporary objects */
355#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
356/* Simple returning values */
357#define SWIG_BADOBJ (SWIG_ERROR)
358#define SWIG_OLDOBJ (SWIG_OK)
359#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
360#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
361/* Check, add and del object mask methods */
362#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
363#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
364#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
365#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
366#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
367#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
368
369/* Cast-Rank Mode */
370#if defined(SWIG_CASTRANK_MODE)
371# ifndef SWIG_TypeRank
372# define SWIG_TypeRank unsigned long
373# endif
374# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
375# define SWIG_MAXCASTRANK (2)
376# endif
377# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
378# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
380 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
381}
383 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
384}
385#else /* no cast-rank mode */
386# define SWIG_AddCast(r) (r)
387# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
388#endif
389
390
391#include <string.h>
392
393#ifdef __cplusplus
394extern "C" {
395#endif
396
397typedef void *(*swig_converter_func)(void *, int *);
398typedef struct swig_type_info *(*swig_dycast_func)(void **);
399
400/* Structure to store information on one type */
401typedef struct swig_type_info {
402 const char *name; /* mangled name of this type */
403 const char *str; /* human readable name of this type */
404 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
405 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
406 void *clientdata; /* language specific type data */
407 int owndata; /* flag if the structure owns the clientdata */
409
410/* Structure to store a type and conversion function used for casting */
411typedef struct swig_cast_info {
412 swig_type_info *type; /* pointer to type that is equivalent to this type */
413 swig_converter_func converter; /* function to cast the void pointers */
414 struct swig_cast_info *next; /* pointer to next cast in linked list */
415 struct swig_cast_info *prev; /* pointer to the previous cast */
417
418/* Structure used to store module information
419 * Each module generates one structure like this, and the runtime collects
420 * all of these structures and stores them in a circularly linked list.*/
421typedef struct swig_module_info {
422 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
423 size_t size; /* Number of types in this module */
424 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
425 swig_type_info **type_initial; /* Array of initially generated type structures */
426 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
427 void *clientdata; /* Language specific module data */
429
430/*
431 Compare two type names skipping the space characters, therefore
432 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
433
434 Return 0 when the two name types are equivalent, as in
435 strncmp, but skipping ' '.
436*/
437SWIGRUNTIME int
438SWIG_TypeNameComp(const char *f1, const char *l1,
439 const char *f2, const char *l2) {
440 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
441 while ((*f1 == ' ') && (f1 != l1)) ++f1;
442 while ((*f2 == ' ') && (f2 != l2)) ++f2;
443 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
444 }
445 return (int)((l1 - f1) - (l2 - f2));
446}
447
448/*
449 Check type equivalence in a name list like <name1>|<name2>|...
450 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
451*/
452SWIGRUNTIME int
453SWIG_TypeCmp(const char *nb, const char *tb) {
454 int equiv = 1;
455 const char* te = tb + strlen(tb);
456 const char* ne = nb;
457 while (equiv != 0 && *ne) {
458 for (nb = ne; *ne; ++ne) {
459 if (*ne == '|') break;
460 }
461 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
462 if (*ne) ++ne;
463 }
464 return equiv;
465}
466
467/*
468 Check type equivalence in a name list like <name1>|<name2>|...
469 Return 0 if not equal, 1 if equal
470*/
471SWIGRUNTIME int
472SWIG_TypeEquiv(const char *nb, const char *tb) {
473 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
474}
475
476/*
477 Check the typename
478*/
480SWIG_TypeCheck(const char *c, swig_type_info *ty) {
481 if (ty) {
482 swig_cast_info *iter = ty->cast;
483 while (iter) {
484 if (strcmp(iter->type->name, c) == 0) {
485 if (iter == ty->cast)
486 return iter;
487 /* Move iter to the top of the linked list */
488 iter->prev->next = iter->next;
489 if (iter->next)
490 iter->next->prev = iter->prev;
491 iter->next = ty->cast;
492 iter->prev = 0;
493 if (ty->cast) ty->cast->prev = iter;
494 ty->cast = iter;
495 return iter;
496 }
497 iter = iter->next;
498 }
499 }
500 return 0;
501}
502
503/*
504 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
505*/
508 if (ty) {
509 swig_cast_info *iter = ty->cast;
510 while (iter) {
511 if (iter->type == from) {
512 if (iter == ty->cast)
513 return iter;
514 /* Move iter to the top of the linked list */
515 iter->prev->next = iter->next;
516 if (iter->next)
517 iter->next->prev = iter->prev;
518 iter->next = ty->cast;
519 iter->prev = 0;
520 if (ty->cast) ty->cast->prev = iter;
521 ty->cast = iter;
522 return iter;
523 }
524 iter = iter->next;
525 }
526 }
527 return 0;
528}
529
530/*
531 Cast a pointer up an inheritance hierarchy
532*/
534SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
535 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
536}
537
538/*
539 Dynamic pointer casting. Down an inheritance hierarchy
540*/
543 swig_type_info *lastty = ty;
544 if (!ty || !ty->dcast) return ty;
545 while (ty && (ty->dcast)) {
546 ty = (*ty->dcast)(ptr);
547 if (ty) lastty = ty;
548 }
549 return lastty;
550}
551
552/*
553 Return the name associated with this type
554*/
555SWIGRUNTIMEINLINE const char *
557 return ty->name;
558}
559
560/*
561 Return the pretty name associated with this type,
562 that is an unmangled type name in a form presentable to the user.
563*/
564SWIGRUNTIME const char *
566 /* The "str" field contains the equivalent pretty names of the
567 type, separated by vertical-bar characters. Choose the last
568 name. It should be the most specific; a fully resolved name
569 but not necessarily with default template parameters expanded. */
570 if (!type) return NULL;
571 if (type->str != NULL) {
572 const char *last_name = type->str;
573 const char *s;
574 for (s = type->str; *s; s++)
575 if (*s == '|') last_name = s+1;
576 return last_name;
577 }
578 else
579 return type->name;
580}
581
582/*
583 Set the clientdata field for a type
584*/
585SWIGRUNTIME void
587 swig_cast_info *cast = ti->cast;
588 /* if (ti->clientdata == clientdata) return; */
590
591 while (cast) {
592 if (!cast->converter) {
593 swig_type_info *tc = cast->type;
594 if (!tc->clientdata) {
596 }
597 }
598 cast = cast->next;
599 }
600}
601SWIGRUNTIME void
606
607/*
608 Search for a swig_type_info structure only by mangled name
609 Search is a O(log #types)
610
611 We start searching at module start, and finish searching when start == end.
612 Note: if start == end at the beginning of the function, we go all the way around
613 the circular list.
614*/
617 swig_module_info *end,
618 const char *name) {
619 swig_module_info *iter = start;
620 do {
621 if (iter->size) {
622 size_t l = 0;
623 size_t r = iter->size - 1;
624 do {
625 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
626 size_t i = (l + r) >> 1;
627 const char *iname = iter->types[i]->name;
628 if (iname) {
629 int compare = strcmp(name, iname);
630 if (compare == 0) {
631 return iter->types[i];
632 } else if (compare < 0) {
633 if (i) {
634 r = i - 1;
635 } else {
636 break;
637 }
638 } else if (compare > 0) {
639 l = i + 1;
640 }
641 } else {
642 break; /* should never happen */
643 }
644 } while (l <= r);
645 }
646 iter = iter->next;
647 } while (iter != end);
648 return 0;
649}
650
651/*
652 Search for a swig_type_info structure for either a mangled name or a human readable name.
653 It first searches the mangled names of the types, which is a O(log #types)
654 If a type is not found it then searches the human readable names, which is O(#types).
655
656 We start searching at module start, and finish searching when start == end.
657 Note: if start == end at the beginning of the function, we go all the way around
658 the circular list.
659*/
662 swig_module_info *end,
663 const char *name) {
664 /* STEP 1: Search the name field using binary search */
666 if (ret) {
667 return ret;
668 } else {
669 /* STEP 2: If the type hasn't been found, do a complete search
670 of the str field (the human readable name) */
671 swig_module_info *iter = start;
672 do {
673 size_t i = 0;
674 for (; i < iter->size; ++i) {
675 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
676 return iter->types[i];
677 }
678 iter = iter->next;
679 } while (iter != end);
680 }
681
682 /* neither found a match */
683 return 0;
684}
685
686/*
687 Pack binary data into a string
688*/
689SWIGRUNTIME char *
690SWIG_PackData(char *c, void *ptr, size_t sz) {
691 static const char hex[17] = "0123456789abcdef";
692 const unsigned char *u = (unsigned char *) ptr;
693 const unsigned char *eu = u + sz;
694 for (; u != eu; ++u) {
695 unsigned char uu = *u;
696 *(c++) = hex[(uu & 0xf0) >> 4];
697 *(c++) = hex[uu & 0xf];
698 }
699 return c;
700}
701
702/*
703 Unpack binary data from a string
704*/
705SWIGRUNTIME const char *
706SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
707 unsigned char *u = (unsigned char *) ptr;
708 const unsigned char *eu = u + sz;
709 for (; u != eu; ++u) {
710 char d = *(c++);
711 unsigned char uu;
712 if ((d >= '0') && (d <= '9'))
713 uu = (unsigned char)((d - '0') << 4);
714 else if ((d >= 'a') && (d <= 'f'))
715 uu = (unsigned char)((d - ('a'-10)) << 4);
716 else
717 return (char *) 0;
718 d = *(c++);
719 if ((d >= '0') && (d <= '9'))
720 uu |= (unsigned char)(d - '0');
721 else if ((d >= 'a') && (d <= 'f'))
722 uu |= (unsigned char)(d - ('a'-10));
723 else
724 return (char *) 0;
725 *u = uu;
726 }
727 return c;
728}
729
730/*
731 Pack 'void *' into a string buffer.
732*/
733SWIGRUNTIME char *
734SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
735 char *r = buff;
736 if ((2*sizeof(void *) + 2) > bsz) return 0;
737 *(r++) = '_';
738 r = SWIG_PackData(r,&ptr,sizeof(void *));
739 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
740 strcpy(r,name);
741 return buff;
742}
743
744SWIGRUNTIME const char *
745SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
746 if (*c != '_') {
747 if (strcmp(c,"NULL") == 0) {
748 *ptr = (void *) 0;
749 return name;
750 } else {
751 return 0;
752 }
753 }
754 return SWIG_UnpackData(++c,ptr,sizeof(void *));
755}
756
757SWIGRUNTIME char *
758SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
759 char *r = buff;
760 size_t lname = (name ? strlen(name) : 0);
761 if ((2*sz + 2 + lname) > bsz) return 0;
762 *(r++) = '_';
763 r = SWIG_PackData(r,ptr,sz);
764 if (lname) {
765 strncpy(r,name,lname+1);
766 } else {
767 *r = 0;
768 }
769 return buff;
770}
771
772SWIGRUNTIME const char *
773SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
774 if (*c != '_') {
775 if (strcmp(c,"NULL") == 0) {
776 memset(ptr,0,sz);
777 return name;
778 } else {
779 return 0;
780 }
781 }
782 return SWIG_UnpackData(++c,ptr,sz);
783}
784
785#ifdef __cplusplus
786}
787#endif
788
789/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
790#define SWIG_UnknownError -1
791#define SWIG_IOError -2
792#define SWIG_RuntimeError -3
793#define SWIG_IndexError -4
794#define SWIG_TypeError -5
795#define SWIG_DivisionByZero -6
796#define SWIG_OverflowError -7
797#define SWIG_SyntaxError -8
798#define SWIG_ValueError -9
799#define SWIG_SystemError -10
800#define SWIG_AttributeError -11
801#define SWIG_MemoryError -12
802#define SWIG_NullReferenceError -13
803
804
805/* Compatibility macros for Python 3 */
806#if PY_VERSION_HEX >= 0x03000000
807
808#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
809#define PyInt_Check(x) PyLong_Check(x)
810#define PyInt_AsLong(x) PyLong_AsLong(x)
811#define PyInt_FromLong(x) PyLong_FromLong(x)
812#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
813#define PyString_Check(name) PyBytes_Check(name)
814#define PyString_FromString(x) PyUnicode_FromString(x)
815#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
816#define PyString_AsString(str) PyBytes_AsString(str)
817#define PyString_Size(str) PyBytes_Size(str)
818#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
819#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
820#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
821
822#endif
823
824#ifndef Py_TYPE
825# define Py_TYPE(op) ((op)->ob_type)
826#endif
827
828/* SWIG APIs for compatibility of both Python 2 & 3 */
829
830#if PY_VERSION_HEX >= 0x03000000
831# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
832#else
833# define SWIG_Python_str_FromFormat PyString_FromFormat
834#endif
835
836
837/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */
838SWIGINTERN const char *
839SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
840{
841#if PY_VERSION_HEX >= 0x03030000
842# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
843 *pbytes = NULL;
844 return PyUnicode_AsUTF8AndSize(str, psize);
845# else
846 *pbytes = PyUnicode_AsUTF8String(str);
847 const char *chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL;
848 if (chars && psize)
849 *psize = PyBytes_Size(*pbytes);
850 return chars;
851# endif
852#else
853 char *chars = NULL;
854 *pbytes = NULL;
855 PyString_AsStringAndSize(str, &chars, psize);
856 return chars;
857#endif
858}
859
860SWIGINTERN PyObject*
862{
863#if PY_VERSION_HEX >= 0x03000000
864 return PyUnicode_FromString(c);
865#else
866 return PyString_FromString(c);
867#endif
868}
869
870#ifndef PyObject_DEL
871# define PyObject_DEL PyObject_Del
872#endif
873
874/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
875# define SWIGPY_USE_CAPSULE
876#ifdef SWIGPYTHON_BUILTIN
877# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
878#else
879# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
880#endif
881# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
882
883#if PY_VERSION_HEX < 0x03020000
884#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
885#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
886#define Py_hash_t long
887#endif
888
889#ifdef Py_LIMITED_API
890# define PyTuple_GET_ITEM PyTuple_GetItem
891/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used
892 interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */
893# define PyTuple_SET_ITEM PyTuple_SetItem
894# define PyTuple_GET_SIZE PyTuple_Size
895# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
896# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
897# define PyCFunction_GET_SELF PyCFunction_GetSelf
898# define PyList_GET_ITEM PyList_GetItem
899# define PyList_SET_ITEM PyList_SetItem
900# define PySliceObject PyObject
901#endif
902
903/* -----------------------------------------------------------------------------
904 * error manipulation
905 * ----------------------------------------------------------------------------- */
906
907SWIGRUNTIME PyObject*
909 PyObject* type = 0;
910 switch(code) {
911 case SWIG_MemoryError:
912 type = PyExc_MemoryError;
913 break;
914 case SWIG_IOError:
915 type = PyExc_IOError;
916 break;
918 type = PyExc_RuntimeError;
919 break;
920 case SWIG_IndexError:
921 type = PyExc_IndexError;
922 break;
923 case SWIG_TypeError:
924 type = PyExc_TypeError;
925 break;
927 type = PyExc_ZeroDivisionError;
928 break;
930 type = PyExc_OverflowError;
931 break;
932 case SWIG_SyntaxError:
933 type = PyExc_SyntaxError;
934 break;
935 case SWIG_ValueError:
936 type = PyExc_ValueError;
937 break;
938 case SWIG_SystemError:
939 type = PyExc_SystemError;
940 break;
942 type = PyExc_AttributeError;
943 break;
944 default:
945 type = PyExc_RuntimeError;
946 }
947 return type;
948}
949
950
951SWIGRUNTIME void
952SWIG_Python_AddErrorMsg(const char* mesg)
953{
954 PyObject *type = 0;
955 PyObject *value = 0;
956 PyObject *traceback = 0;
957
958 if (PyErr_Occurred())
959 PyErr_Fetch(&type, &value, &traceback);
960 if (value) {
961 PyObject *old_str = PyObject_Str(value);
962 PyObject *bytes = NULL;
963 const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
964 PyErr_Clear();
965 Py_XINCREF(type);
966 if (tmp)
967 PyErr_Format(type, "%s %s", tmp, mesg);
968 else
969 PyErr_Format(type, "%s", mesg);
970 Py_XDECREF(bytes);
971 Py_DECREF(old_str);
972 Py_DECREF(value);
973 } else {
974 PyErr_SetString(PyExc_RuntimeError, mesg);
975 }
976}
977
978SWIGRUNTIME int
980{
981 PyObject *error;
982 if (obj)
983 return 0;
984 error = PyErr_Occurred();
985 return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
986}
987
988SWIGRUNTIME void
990{
992 /* Use existing TypeError to preserve stacktrace and enhance with given message */
993 PyObject *newvalue;
994 PyObject *type = NULL, *value = NULL, *traceback = NULL;
995 PyErr_Fetch(&type, &value, &traceback);
996#if PY_VERSION_HEX >= 0x03000000
997 newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
998#else
999 newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
1000#endif
1001 if (newvalue) {
1002 Py_XDECREF(value);
1003 PyErr_Restore(type, newvalue, traceback);
1004 } else {
1005 PyErr_Restore(type, value, traceback);
1006 }
1007 } else {
1008 /* Raise TypeError using given message */
1009 PyErr_SetString(PyExc_TypeError, message);
1010 }
1011}
1012
1013#if defined(SWIG_PYTHON_NO_THREADS)
1014# if defined(SWIG_PYTHON_THREADS)
1015# undef SWIG_PYTHON_THREADS
1016# endif
1017#endif
1018#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1019# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1020# define SWIG_PYTHON_USE_GIL
1021# endif
1022# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1023# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1024# if PY_VERSION_HEX < 0x03070000
1025# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1026# else
1027# define SWIG_PYTHON_INITIALIZE_THREADS
1028# endif
1029# endif
1030# ifdef __cplusplus /* C++ code */
1031 class SWIG_Python_Thread_Block {
1032 bool status;
1033 PyGILState_STATE state;
1034 public:
1035 void end() { if (status) { PyGILState_Release(state); status = false;} }
1036 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1037 ~SWIG_Python_Thread_Block() { end(); }
1038 };
1039 class SWIG_Python_Thread_Allow {
1040 bool status;
1041 PyThreadState *save;
1042 public:
1043 void end() { if (status) { status = false; PyEval_RestoreThread(save); }}
1044 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1045 ~SWIG_Python_Thread_Allow() { end(); }
1046 };
1047# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1048# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1049# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1050# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1051# else /* C code */
1052# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1053# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1054# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1055# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1056# endif
1057# else /* Old thread way, not implemented, user must provide it */
1058# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1059# define SWIG_PYTHON_INITIALIZE_THREADS
1060# endif
1061# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1062# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1063# endif
1064# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1065# define SWIG_PYTHON_THREAD_END_BLOCK
1066# endif
1067# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1068# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1069# endif
1070# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1071# define SWIG_PYTHON_THREAD_END_ALLOW
1072# endif
1073# endif
1074#else /* No thread support */
1075# define SWIG_PYTHON_INITIALIZE_THREADS
1076# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1077# define SWIG_PYTHON_THREAD_END_BLOCK
1078# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1079# define SWIG_PYTHON_THREAD_END_ALLOW
1080#endif
1081
1082/* -----------------------------------------------------------------------------
1083 * Python API portion that goes into the runtime
1084 * ----------------------------------------------------------------------------- */
1085
1086#ifdef __cplusplus
1087extern "C" {
1088#endif
1089
1090/* -----------------------------------------------------------------------------
1091 * Constant declarations
1092 * ----------------------------------------------------------------------------- */
1093
1094/* Constant Types */
1095#define SWIG_PY_POINTER 4
1096#define SWIG_PY_BINARY 5
1097
1098/* Constant information structure */
1107
1108#ifdef __cplusplus
1109}
1110#endif
1111
1112
1113/* -----------------------------------------------------------------------------
1114 * pyrun.swg
1115 *
1116 * This file contains the runtime support for Python modules
1117 * and includes code for managing global variables and pointer
1118 * type checking.
1119 *
1120 * ----------------------------------------------------------------------------- */
1121
1122#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
1123# error "This version of SWIG only supports Python >= 2.7"
1124#endif
1125
1126#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
1127# error "This version of SWIG only supports Python 3 >= 3.3"
1128#endif
1129
1130/* Common SWIG API */
1131
1132/* for raw pointers */
1133#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1134#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1135#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1136
1137#ifdef SWIGPYTHON_BUILTIN
1138#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1139#else
1140#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1141#endif
1142
1143#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1144
1145#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1146#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1147#define swig_owntype int
1148
1149/* for raw packed data */
1150#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1151#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1152
1153/* for class or struct pointers */
1154#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1155#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1156
1157/* for C or C++ function pointers */
1158#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1159#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1160
1161/* for C++ member pointers, ie, member methods */
1162#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1163#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1164
1165
1166/* Runtime API */
1167
1168#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1169#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1170#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1171
1172#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1173#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1174#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1175#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1176#define SWIG_fail goto fail
1177
1178
1179/* Runtime API implementation */
1180
1181/* Error manipulation */
1182
1183SWIGINTERN void
1184SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1186 PyErr_SetObject(errtype, obj);
1187 Py_DECREF(obj);
1189}
1190
1191SWIGINTERN void
1192SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1194 PyErr_SetString(errtype, msg);
1196}
1197
1198#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1199
1200/* Set a constant value */
1201
1202#if defined(SWIGPYTHON_BUILTIN)
1203
1204SWIGINTERN void
1205SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1206 PyObject *s = PyString_InternFromString(key);
1207 PyList_Append(seq, s);
1208 Py_DECREF(s);
1209}
1210
1211SWIGINTERN void
1212SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1213 PyDict_SetItemString(d, name, obj);
1214 Py_DECREF(obj);
1215 if (public_interface)
1216 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1217}
1218
1219#else
1220
1221SWIGINTERN void
1222SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1223 PyDict_SetItemString(d, name, obj);
1224 Py_DECREF(obj);
1225}
1226
1227#endif
1228
1229/* Append a value to the result obj */
1230
1231SWIGINTERN PyObject*
1232SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1233 if (!result) {
1234 result = obj;
1235 } else if (result == Py_None) {
1236 Py_DECREF(result);
1237 result = obj;
1238 } else {
1239 if (!PyList_Check(result)) {
1240 PyObject *o2 = result;
1241 result = PyList_New(1);
1242 if (result) {
1243 PyList_SET_ITEM(result, 0, o2);
1244 } else {
1245 Py_DECREF(obj);
1246 return o2;
1247 }
1248 }
1249 PyList_Append(result,obj);
1250 Py_DECREF(obj);
1251 }
1252 return result;
1253}
1254
1255/* Unpack the argument tuple */
1256
1257SWIGINTERN Py_ssize_t
1258SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1259{
1260 if (!args) {
1261 if (!min && !max) {
1262 return 1;
1263 } else {
1264 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1265 name, (min == max ? "" : "at least "), (int)min);
1266 return 0;
1267 }
1268 }
1269 if (!PyTuple_Check(args)) {
1270 if (min <= 1 && max >= 1) {
1271 Py_ssize_t i;
1272 objs[0] = args;
1273 for (i = 1; i < max; ++i) {
1274 objs[i] = 0;
1275 }
1276 return 2;
1277 }
1278 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1279 return 0;
1280 } else {
1281 Py_ssize_t l = PyTuple_GET_SIZE(args);
1282 if (l < min) {
1283 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1284 name, (min == max ? "" : "at least "), (int)min, (int)l);
1285 return 0;
1286 } else if (l > max) {
1287 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1288 name, (min == max ? "" : "at most "), (int)max, (int)l);
1289 return 0;
1290 } else {
1291 Py_ssize_t i;
1292 for (i = 0; i < l; ++i) {
1293 objs[i] = PyTuple_GET_ITEM(args, i);
1294 }
1295 for (; l < max; ++l) {
1296 objs[l] = 0;
1297 }
1298 return i + 1;
1299 }
1300 }
1301}
1302
1303SWIGINTERN int
1304SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
1305 int no_kwargs = 1;
1306 if (kwargs) {
1307 assert(PyDict_Check(kwargs));
1308 if (PyDict_Size(kwargs) > 0) {
1309 PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
1310 no_kwargs = 0;
1311 }
1312 }
1313 return no_kwargs;
1314}
1315
1316/* A functor is a function object with one single object argument */
1317#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1318
1319/*
1320 Helper for static pointer initialization for both C and C++ code, for example
1321 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1322*/
1323#ifdef __cplusplus
1324#define SWIG_STATIC_POINTER(var) var
1325#else
1326#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1327#endif
1328
1329#ifdef __cplusplus
1330extern "C" {
1331#endif
1332
1333/* Python-specific SWIG API */
1334#define SWIG_newvarlink() SWIG_Python_newvarlink()
1335#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
1336#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
1337
1338/* -----------------------------------------------------------------------------
1339 * global variable support code.
1340 * ----------------------------------------------------------------------------- */
1341
1342typedef struct swig_globalvar {
1343 char *name; /* Name of global variable */
1344 PyObject *(*get_attr)(void); /* Return the current value */
1345 int (*set_attr)(PyObject *); /* Set the value */
1348
1353
1354SWIGINTERN PyObject *
1356#if PY_VERSION_HEX >= 0x03000000
1357 return PyUnicode_InternFromString("<Swig global variables>");
1358#else
1359 return PyString_FromString("<Swig global variables>");
1360#endif
1361}
1362
1363SWIGINTERN PyObject *
1364swig_varlink_str(PyObject *o) {
1366#if PY_VERSION_HEX >= 0x03000000
1367 PyObject *str = PyUnicode_InternFromString("(");
1368 PyObject *tail;
1369 PyObject *joined;
1370 swig_globalvar *var;
1371 for (var = v->vars; var; var=var->next) {
1372 tail = PyUnicode_FromString(var->name);
1373 joined = PyUnicode_Concat(str, tail);
1374 Py_DecRef(str);
1375 Py_DecRef(tail);
1376 str = joined;
1377 if (var->next) {
1378 tail = PyUnicode_InternFromString(", ");
1379 joined = PyUnicode_Concat(str, tail);
1380 Py_DecRef(str);
1381 Py_DecRef(tail);
1382 str = joined;
1383 }
1384 }
1385 tail = PyUnicode_InternFromString(")");
1386 joined = PyUnicode_Concat(str, tail);
1387 Py_DecRef(str);
1388 Py_DecRef(tail);
1389 str = joined;
1390#else
1391 PyObject *str = PyString_FromString("(");
1392 swig_globalvar *var;
1393 for (var = v->vars; var; var=var->next) {
1394 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
1395 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
1396 }
1397 PyString_ConcatAndDel(&str,PyString_FromString(")"));
1398#endif
1399 return str;
1400}
1401
1402SWIGINTERN void
1405 swig_globalvar *var = v->vars;
1406 while (var) {
1407 swig_globalvar *n = var->next;
1408 free(var->name);
1409 free(var);
1410 var = n;
1411 }
1412}
1413
1414SWIGINTERN PyObject *
1415swig_varlink_getattr(PyObject *o, char *n) {
1417 PyObject *res = NULL;
1418 swig_globalvar *var = v->vars;
1419 while (var) {
1420 if (strcmp(var->name,n) == 0) {
1421 res = (*var->get_attr)();
1422 break;
1423 }
1424 var = var->next;
1425 }
1426 if (res == NULL && !PyErr_Occurred()) {
1427 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
1428 }
1429 return res;
1430}
1431
1432SWIGINTERN int
1433swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
1435 int res = 1;
1436 swig_globalvar *var = v->vars;
1437 while (var) {
1438 if (strcmp(var->name,n) == 0) {
1439 res = (*var->set_attr)(p);
1440 break;
1441 }
1442 var = var->next;
1443 }
1444 if (res == 1 && !PyErr_Occurred()) {
1445 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
1446 }
1447 return res;
1448}
1449
1450SWIGINTERN PyTypeObject*
1452 static char varlink__doc__[] = "Swig var link object";
1453#ifndef Py_LIMITED_API
1454 static PyTypeObject varlink_type;
1455 static int type_init = 0;
1456 if (!type_init) {
1457 const PyTypeObject tmp = {
1458#if PY_VERSION_HEX >= 0x03000000
1459 PyVarObject_HEAD_INIT(NULL, 0)
1460#else
1461 PyObject_HEAD_INIT(NULL)
1462 0, /* ob_size */
1463#endif
1464 "swigvarlink", /* tp_name */
1465 sizeof(swig_varlinkobject), /* tp_basicsize */
1466 0, /* tp_itemsize */
1467 (destructor) swig_varlink_dealloc, /* tp_dealloc */
1468#if PY_VERSION_HEX < 0x030800b4
1469 (printfunc)0, /*tp_print*/
1470#else
1471 (Py_ssize_t)0, /*tp_vectorcall_offset*/
1472#endif
1473 (getattrfunc) swig_varlink_getattr, /* tp_getattr */
1474 (setattrfunc) swig_varlink_setattr, /* tp_setattr */
1475 0, /* tp_compare */
1476 (reprfunc) swig_varlink_repr, /* tp_repr */
1477 0, /* tp_as_number */
1478 0, /* tp_as_sequence */
1479 0, /* tp_as_mapping */
1480 0, /* tp_hash */
1481 0, /* tp_call */
1482 (reprfunc) swig_varlink_str, /* tp_str */
1483 0, /* tp_getattro */
1484 0, /* tp_setattro */
1485 0, /* tp_as_buffer */
1486 0, /* tp_flags */
1487 varlink__doc__, /* tp_doc */
1488 0, /* tp_traverse */
1489 0, /* tp_clear */
1490 0, /* tp_richcompare */
1491 0, /* tp_weaklistoffset */
1492 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
1493 0, /* tp_del */
1494 0, /* tp_version_tag */
1495#if PY_VERSION_HEX >= 0x03040000
1496 0, /* tp_finalize */
1497#endif
1498#if PY_VERSION_HEX >= 0x03080000
1499 0, /* tp_vectorcall */
1500#endif
1501#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
1502 0, /* tp_print */
1503#endif
1504#if PY_VERSION_HEX >= 0x030C0000
1505 0, /* tp_watched */
1506#endif
1507#ifdef COUNT_ALLOCS
1508 0, /* tp_allocs */
1509 0, /* tp_frees */
1510 0, /* tp_maxalloc */
1511 0, /* tp_prev */
1512 0 /* tp_next */
1513#endif
1514 };
1515 varlink_type = tmp;
1516 type_init = 1;
1517 if (PyType_Ready(&varlink_type) < 0)
1518 return NULL;
1519 }
1520 return &varlink_type;
1521#else
1522 PyType_Slot slots[] = {
1523 { Py_tp_dealloc, (void *)swig_varlink_dealloc },
1524 { Py_tp_repr, (void *)swig_varlink_repr },
1525 { Py_tp_getattr, (void *)swig_varlink_getattr },
1526 { Py_tp_setattr, (void *)swig_varlink_setattr },
1527 { Py_tp_str, (void *)swig_varlink_str },
1528 { Py_tp_doc, (void *)varlink__doc__ },
1529 { 0, NULL }
1530 };
1531 PyType_Spec spec = {
1532 "swigvarlink",
1533 sizeof(swig_varlinkobject),
1534 0,
1535 Py_TPFLAGS_DEFAULT,
1536 slots
1537 };
1538 return (PyTypeObject *)PyType_FromSpec(&spec);
1539#endif
1540}
1541
1542/* Create a variable linking object for use later */
1543SWIGINTERN PyObject *
1545 swig_varlinkobject *result = PyObject_New(swig_varlinkobject, swig_varlink_type());
1546 if (result) {
1547 result->vars = 0;
1548 }
1549 return ((PyObject*) result);
1550}
1551
1552SWIGINTERN void
1553SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
1555 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
1556 if (gv) {
1557 size_t size = strlen(name)+1;
1558 gv->name = (char *)malloc(size);
1559 if (gv->name) {
1560 memcpy(gv->name, name, size);
1561 gv->get_attr = get_attr;
1562 gv->set_attr = set_attr;
1563 gv->next = v->vars;
1564 }
1565 }
1566 v->vars = gv;
1567}
1568
1569
1570static PyObject *Swig_Globals_global = NULL;
1571
1572SWIGINTERN PyObject *
1574 if (Swig_Globals_global == NULL) {
1576 }
1577 return Swig_Globals_global;
1578}
1579
1580#ifdef __cplusplus
1581}
1582#endif
1583
1584/* -----------------------------------------------------------------------------
1585 * Pointer declarations
1586 * ----------------------------------------------------------------------------- */
1587
1588/* Flags for new pointer objects */
1589#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1590#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1591
1592#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1593
1594#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1595#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1596
1597#ifdef __cplusplus
1598extern "C" {
1599#endif
1600
1601/* The python void return value */
1602
1603SWIGRUNTIMEINLINE PyObject *
1605{
1606 PyObject *none = Py_None;
1607 Py_INCREF(none);
1608 return none;
1609}
1610
1611/* SwigPyClientData */
1612
1613typedef struct {
1614 PyObject *klass;
1615 PyObject *newraw;
1616 PyObject *newargs;
1617 PyObject *destroy;
1620 PyTypeObject *pytype;
1622
1625{
1627 int fail = data ? data->implicitconv : 0;
1628 if (fail)
1629 PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
1630 return fail;
1631}
1632
1633SWIGRUNTIMEINLINE PyObject *
1635 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1636 PyObject *klass = data ? data->klass : 0;
1637 return (klass ? klass : PyExc_RuntimeError);
1638}
1639
1640
1643{
1644 if (!obj) {
1645 return 0;
1646 } else {
1647 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1648 /* the klass element */
1649 data->klass = obj;
1650 Py_INCREF(data->klass);
1651 /* the newraw method and newargs arguments used to create a new raw instance */
1652 if (PyClass_Check(obj)) {
1653 data->newraw = 0;
1654 Py_INCREF(obj);
1655 data->newargs = obj;
1656 } else {
1657 data->newraw = PyObject_GetAttrString(data->klass, "__new__");
1658 if (data->newraw) {
1659 data->newargs = PyTuple_New(1);
1660 if (data->newargs) {
1661 Py_INCREF(obj);
1662 PyTuple_SET_ITEM(data->newargs, 0, obj);
1663 } else {
1664 Py_DECREF(data->newraw);
1665 Py_DECREF(data->klass);
1666 free(data);
1667 return 0;
1668 }
1669 } else {
1670 Py_INCREF(obj);
1671 data->newargs = obj;
1672 }
1673 }
1674 /* the destroy method, aka as the C++ delete method */
1675 data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1676 if (PyErr_Occurred()) {
1677 PyErr_Clear();
1678 data->destroy = 0;
1679 }
1680 if (data->destroy) {
1681 data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
1682 } else {
1683 data->delargs = 0;
1684 }
1685 data->implicitconv = 0;
1686 data->pytype = 0;
1687 return data;
1688 }
1689}
1690
1691SWIGRUNTIME void
1693{
1694 Py_XDECREF(data->klass);
1695 Py_XDECREF(data->newraw);
1696 Py_XDECREF(data->newargs);
1697 Py_XDECREF(data->destroy);
1698 free(data);
1699}
1700
1701/* =============== SwigPyObject =====================*/
1702
1703typedef struct {
1704 PyObject_HEAD
1705 void *ptr;
1707 int own;
1708 PyObject *next;
1709#ifdef SWIGPYTHON_BUILTIN
1710 PyObject *dict;
1711#endif
1712} SwigPyObject;
1713
1714
1715#ifdef SWIGPYTHON_BUILTIN
1716
1717SWIGRUNTIME PyObject *
1718SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1719{
1720 SwigPyObject *sobj = (SwigPyObject *)v;
1721
1722 if (!sobj->dict)
1723 sobj->dict = PyDict_New();
1724
1725 Py_XINCREF(sobj->dict);
1726 return sobj->dict;
1727}
1728
1729#endif
1730
1731SWIGRUNTIME PyObject *
1733{
1734 return PyLong_FromVoidPtr(v->ptr);
1735}
1736
1737SWIGRUNTIME PyObject *
1739{
1740 PyObject *res = NULL;
1741 PyObject *args = PyTuple_New(1);
1742 if (args) {
1743 PyObject *val = SwigPyObject_long(v);
1744 if (val) {
1745 PyObject *ofmt;
1746 PyTuple_SET_ITEM(args, 0, val);
1747 ofmt = SWIG_Python_str_FromChar(fmt);
1748 if (ofmt) {
1749#if PY_VERSION_HEX >= 0x03000000
1750 res = PyUnicode_Format(ofmt,args);
1751#else
1752 res = PyString_Format(ofmt,args);
1753#endif
1754 Py_DECREF(ofmt);
1755 }
1756 }
1757 Py_DECREF(args);
1758 }
1759 return res;
1760}
1761
1762SWIGRUNTIME PyObject *
1764{
1765 return SwigPyObject_format("%o",v);
1766}
1767
1768SWIGRUNTIME PyObject *
1770{
1771 return SwigPyObject_format("%x",v);
1772}
1773
1774SWIGRUNTIME PyObject *
1776{
1777 const char *name = SWIG_TypePrettyName(v->ty);
1778 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1779 if (repr && v->next) {
1780 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1781 if (nrep) {
1782# if PY_VERSION_HEX >= 0x03000000
1783 PyObject *joined = PyUnicode_Concat(repr, nrep);
1784 Py_DecRef(repr);
1785 Py_DecRef(nrep);
1786 repr = joined;
1787# else
1788 PyString_ConcatAndDel(&repr,nrep);
1789# endif
1790 } else {
1791 Py_DecRef(repr);
1792 repr = NULL;
1793 }
1794 }
1795 return repr;
1796}
1797
1798/* We need a version taking two PyObject* parameters so it's a valid
1799 * PyCFunction to use in swigobject_methods[]. */
1800SWIGRUNTIME PyObject *
1801SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1802{
1803 return SwigPyObject_repr((SwigPyObject*)v);
1804}
1805
1806SWIGRUNTIME int
1808{
1809 void *i = v->ptr;
1810 void *j = w->ptr;
1811 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1812}
1813
1814/* Added for Python 3.x, would it also be useful for Python 2.x? */
1815SWIGRUNTIME PyObject*
1817{
1818 PyObject* res = NULL;
1819 if (!PyErr_Occurred()) {
1820 if (op != Py_EQ && op != Py_NE) {
1821 Py_INCREF(Py_NotImplemented);
1822 return Py_NotImplemented;
1823 }
1824 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1825 }
1826 return res;
1827}
1828
1829
1830SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1831
1832#ifdef SWIGPYTHON_BUILTIN
1833static swig_type_info *SwigPyObject_stype = 0;
1834SWIGRUNTIME PyTypeObject*
1835SwigPyObject_type(void) {
1836 SwigPyClientData *cd;
1837 assert(SwigPyObject_stype);
1838 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1839 assert(cd);
1840 assert(cd->pytype);
1841 return cd->pytype;
1842}
1843#else
1844SWIGRUNTIME PyTypeObject*
1846 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1847 return type;
1848}
1849#endif
1850
1852SwigPyObject_Check(PyObject *op) {
1853 PyTypeObject *target_tp = SwigPyObject_type();
1854 PyTypeObject *op_type = Py_TYPE(op);
1855#ifdef SWIGPYTHON_BUILTIN
1856 if (PyType_IsSubtype(op_type, target_tp))
1857 return 1;
1858 return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
1859#else
1860 if (op_type == target_tp)
1861 return 1;
1862# ifdef Py_LIMITED_API
1863 int cmp;
1864 PyObject *tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
1865 if (!tp_name)
1866 return 0;
1867 cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject");
1868 Py_DECREF(tp_name);
1869 return cmp == 0;
1870# else
1871 return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
1872# endif
1873#endif
1874}
1875
1876SWIGRUNTIME PyObject *
1877SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1878
1879static PyObject* Swig_Capsule_global = NULL;
1880
1881SWIGRUNTIME void
1883{
1884 SwigPyObject *sobj = (SwigPyObject *) v;
1885 PyObject *next = sobj->next;
1886 if (sobj->own == SWIG_POINTER_OWN) {
1887 swig_type_info *ty = sobj->ty;
1888 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1889 PyObject *destroy = data ? data->destroy : 0;
1890 if (destroy) {
1891 /* destroy is always a VARARGS method */
1892 PyObject *res;
1893
1894 /* PyObject_CallFunction() has the potential to silently drop
1895 the active exception. In cases of unnamed temporary
1896 variable or where we just finished iterating over a generator
1897 StopIteration will be active right now, and this needs to
1898 remain true upon return from SwigPyObject_dealloc. So save
1899 and restore. */
1900
1901 PyObject *type = NULL, *value = NULL, *traceback = NULL;
1902 PyErr_Fetch(&type, &value, &traceback);
1903
1904 if (data->delargs) {
1905 /* we need to create a temporary object to carry the destroy operation */
1906 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1907 if (tmp) {
1908 res = SWIG_Python_CallFunctor(destroy, tmp);
1909 } else {
1910 res = 0;
1911 }
1912 Py_XDECREF(tmp);
1913 } else {
1914 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1915 PyObject *mself = PyCFunction_GET_SELF(destroy);
1916 res = ((*meth)(mself, v));
1917 }
1918 if (!res)
1919 PyErr_WriteUnraisable(destroy);
1920
1921 PyErr_Restore(type, value, traceback);
1922
1923 Py_XDECREF(res);
1924 }
1925#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1926 else {
1927 const char *name = SWIG_TypePrettyName(ty);
1928 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1929 }
1930#endif
1931 Py_XDECREF(Swig_Capsule_global);
1932 }
1933 Py_XDECREF(next);
1934#ifdef SWIGPYTHON_BUILTIN
1935 Py_XDECREF(sobj->dict);
1936#endif
1937 PyObject_DEL(v);
1938}
1939
1940SWIGRUNTIME PyObject*
1941SwigPyObject_append(PyObject* v, PyObject* next)
1942{
1943 SwigPyObject *sobj = (SwigPyObject *) v;
1944 if (!SwigPyObject_Check(next)) {
1945 PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1946 return NULL;
1947 }
1948 ((SwigPyObject *)next)->next = sobj->next;
1949 sobj->next = next;
1950 Py_INCREF(next);
1951 return SWIG_Py_Void();
1952}
1953
1954SWIGRUNTIME PyObject*
1955SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1956{
1957 SwigPyObject *sobj = (SwigPyObject *) v;
1958 if (sobj->next) {
1959 Py_INCREF(sobj->next);
1960 return sobj->next;
1961 } else {
1962 return SWIG_Py_Void();
1963 }
1964}
1965
1966SWIGINTERN PyObject*
1967SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1968{
1969 SwigPyObject *sobj = (SwigPyObject *)v;
1970 sobj->own = 0;
1971 return SWIG_Py_Void();
1972}
1973
1974SWIGINTERN PyObject*
1975SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1976{
1977 SwigPyObject *sobj = (SwigPyObject *)v;
1978 sobj->own = SWIG_POINTER_OWN;
1979 return SWIG_Py_Void();
1980}
1981
1982SWIGINTERN PyObject*
1983SwigPyObject_own(PyObject *v, PyObject *args)
1984{
1985 PyObject *val = 0;
1986 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
1987 return NULL;
1988 } else {
1989 SwigPyObject *sobj = (SwigPyObject *)v;
1990 PyObject *obj = PyBool_FromLong(sobj->own);
1991 if (val) {
1992 if (PyObject_IsTrue(val)) {
1993 Py_DECREF(SwigPyObject_acquire(v,args));
1994 } else {
1995 Py_DECREF(SwigPyObject_disown(v,args));
1996 }
1997 }
1998 return obj;
1999 }
2000}
2001
2002static PyMethodDef
2004 {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
2005 {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
2006 {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
2007 {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
2008 {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
2009 {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
2010 {0, 0, 0, 0}
2011};
2012
2013SWIGRUNTIME PyTypeObject*
2015 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
2016#ifndef Py_LIMITED_API
2017 static PyNumberMethods SwigPyObject_as_number = {
2018 (binaryfunc)0, /*nb_add*/
2019 (binaryfunc)0, /*nb_subtract*/
2020 (binaryfunc)0, /*nb_multiply*/
2021 /* nb_divide removed in Python 3 */
2022#if PY_VERSION_HEX < 0x03000000
2023 (binaryfunc)0, /*nb_divide*/
2024#endif
2025 (binaryfunc)0, /*nb_remainder*/
2026 (binaryfunc)0, /*nb_divmod*/
2027 (ternaryfunc)0,/*nb_power*/
2028 (unaryfunc)0, /*nb_negative*/
2029 (unaryfunc)0, /*nb_positive*/
2030 (unaryfunc)0, /*nb_absolute*/
2031 (inquiry)0, /*nb_nonzero*/
2032 0, /*nb_invert*/
2033 0, /*nb_lshift*/
2034 0, /*nb_rshift*/
2035 0, /*nb_and*/
2036 0, /*nb_xor*/
2037 0, /*nb_or*/
2038#if PY_VERSION_HEX < 0x03000000
2039 0, /*nb_coerce*/
2040#endif
2041 (unaryfunc)SwigPyObject_long, /*nb_int*/
2042#if PY_VERSION_HEX < 0x03000000
2043 (unaryfunc)SwigPyObject_long, /*nb_long*/
2044#else
2045 0, /*nb_reserved*/
2046#endif
2047 (unaryfunc)0, /*nb_float*/
2048#if PY_VERSION_HEX < 0x03000000
2049 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
2050 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
2051#endif
2052#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
2053 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
2054#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
2055 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
2056#else
2057 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
2058#endif
2059 };
2060
2061 static PyTypeObject swigpyobject_type;
2062 static int type_init = 0;
2063 if (!type_init) {
2064 const PyTypeObject tmp = {
2065#if PY_VERSION_HEX >= 0x03000000
2066 PyVarObject_HEAD_INIT(NULL, 0)
2067#else
2068 PyObject_HEAD_INIT(NULL)
2069 0, /* ob_size */
2070#endif
2071 "SwigPyObject", /* tp_name */
2072 sizeof(SwigPyObject), /* tp_basicsize */
2073 0, /* tp_itemsize */
2074 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
2075#if PY_VERSION_HEX < 0x030800b4
2076 (printfunc)0, /*tp_print*/
2077#else
2078 (Py_ssize_t)0, /*tp_vectorcall_offset*/
2079#endif
2080 (getattrfunc)0, /* tp_getattr */
2081 (setattrfunc)0, /* tp_setattr */
2082#if PY_VERSION_HEX >= 0x03000000
2083 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
2084#else
2085 (cmpfunc)SwigPyObject_compare, /* tp_compare */
2086#endif
2087 (reprfunc)SwigPyObject_repr, /* tp_repr */
2088 &SwigPyObject_as_number, /* tp_as_number */
2089 0, /* tp_as_sequence */
2090 0, /* tp_as_mapping */
2091 (hashfunc)0, /* tp_hash */
2092 (ternaryfunc)0, /* tp_call */
2093 0, /* tp_str */
2094 PyObject_GenericGetAttr, /* tp_getattro */
2095 0, /* tp_setattro */
2096 0, /* tp_as_buffer */
2097 Py_TPFLAGS_DEFAULT, /* tp_flags */
2098 swigobject_doc, /* tp_doc */
2099 0, /* tp_traverse */
2100 0, /* tp_clear */
2101 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
2102 0, /* tp_weaklistoffset */
2103 0, /* tp_iter */
2104 0, /* tp_iternext */
2105 swigobject_methods, /* tp_methods */
2106 0, /* tp_members */
2107 0, /* tp_getset */
2108 0, /* tp_base */
2109 0, /* tp_dict */
2110 0, /* tp_descr_get */
2111 0, /* tp_descr_set */
2112 0, /* tp_dictoffset */
2113 0, /* tp_init */
2114 0, /* tp_alloc */
2115 0, /* tp_new */
2116 0, /* tp_free */
2117 0, /* tp_is_gc */
2118 0, /* tp_bases */
2119 0, /* tp_mro */
2120 0, /* tp_cache */
2121 0, /* tp_subclasses */
2122 0, /* tp_weaklist */
2123 0, /* tp_del */
2124 0, /* tp_version_tag */
2125#if PY_VERSION_HEX >= 0x03040000
2126 0, /* tp_finalize */
2127#endif
2128#if PY_VERSION_HEX >= 0x03080000
2129 0, /* tp_vectorcall */
2130#endif
2131#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2132 0, /* tp_print */
2133#endif
2134#if PY_VERSION_HEX >= 0x030C0000
2135 0, /* tp_watched */
2136#endif
2137#ifdef COUNT_ALLOCS
2138 0, /* tp_allocs */
2139 0, /* tp_frees */
2140 0, /* tp_maxalloc */
2141 0, /* tp_prev */
2142 0 /* tp_next */
2143#endif
2144 };
2145 swigpyobject_type = tmp;
2146 type_init = 1;
2147 if (PyType_Ready(&swigpyobject_type) != 0)
2148 return NULL;
2149 }
2150 return &swigpyobject_type;
2151#else
2152 PyType_Slot slots[] = {
2153 { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
2154 { Py_tp_repr, (void *)SwigPyObject_repr },
2155 { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
2156 { Py_tp_doc, (void *)swigobject_doc },
2157 { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
2158 { Py_tp_methods, (void *)swigobject_methods },
2159 { Py_nb_int, (void *)SwigPyObject_long },
2160 { 0, NULL }
2161 };
2162 PyType_Spec spec = {
2163 "SwigPyObject",
2164 sizeof(SwigPyObject),
2165 0,
2166 Py_TPFLAGS_DEFAULT,
2167 slots
2168 };
2169 return (PyTypeObject *)PyType_FromSpec(&spec);
2170#endif
2171}
2172
2173SWIGRUNTIME PyObject *
2174SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2175{
2176 SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_type());
2177 if (sobj) {
2178 sobj->ptr = ptr;
2179 sobj->ty = ty;
2180 sobj->own = own;
2181 sobj->next = 0;
2182#ifdef SWIGPYTHON_BUILTIN
2183 sobj->dict = 0;
2184#endif
2185 if (own == SWIG_POINTER_OWN) {
2186 /* Obtain a reference to the Python capsule wrapping the module information, so that the
2187 * module information is correctly destroyed after all SWIG python objects have been freed
2188 * by the GC (and corresponding destructors invoked) */
2189 Py_XINCREF(Swig_Capsule_global);
2190 }
2191 }
2192 return (PyObject *)sobj;
2193}
2194
2195/* -----------------------------------------------------------------------------
2196 * Implements a simple Swig Packed type, and use it instead of string
2197 * ----------------------------------------------------------------------------- */
2198
2199typedef struct {
2200 PyObject_HEAD
2201 void *pack;
2203 size_t size;
2204} SwigPyPacked;
2205
2206SWIGRUNTIME PyObject *
2208{
2209 char result[SWIG_BUFFER_SIZE];
2210 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2211 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2212 } else {
2213 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2214 }
2215}
2216
2217SWIGRUNTIME PyObject *
2219{
2220 char result[SWIG_BUFFER_SIZE];
2221 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2222 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2223 } else {
2224 return SWIG_Python_str_FromChar(v->ty->name);
2225 }
2226}
2227
2228SWIGRUNTIME int
2230{
2231 size_t i = v->size;
2232 size_t j = w->size;
2233 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2234 return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
2235}
2236
2237SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2238
2239SWIGRUNTIME PyTypeObject*
2241 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2242 return type;
2243}
2244
2246SwigPyPacked_Check(PyObject *op) {
2247 PyTypeObject* op_type = Py_TYPE(op);
2248 if (op_type == SwigPyPacked_TypeOnce())
2249 return 1;
2250#ifdef Py_LIMITED_API
2251 int cmp;
2252 PyObject *tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
2253 if (!tp_name)
2254 return 0;
2255 cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked");
2256 Py_DECREF(tp_name);
2257 return cmp == 0;
2258#else
2259 return (strcmp(op_type->tp_name, "SwigPyPacked") == 0);
2260#endif
2261}
2262
2263SWIGRUNTIME void
2265{
2266 if (SwigPyPacked_Check(v)) {
2267 SwigPyPacked *sobj = (SwigPyPacked *) v;
2268 free(sobj->pack);
2269 }
2270 PyObject_DEL(v);
2271}
2272
2273SWIGRUNTIME PyTypeObject*
2275 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2276#ifndef Py_LIMITED_API
2277 static PyTypeObject swigpypacked_type;
2278 static int type_init = 0;
2279 if (!type_init) {
2280 const PyTypeObject tmp = {
2281#if PY_VERSION_HEX>=0x03000000
2282 PyVarObject_HEAD_INIT(NULL, 0)
2283#else
2284 PyObject_HEAD_INIT(NULL)
2285 0, /* ob_size */
2286#endif
2287 "SwigPyPacked", /* tp_name */
2288 sizeof(SwigPyPacked), /* tp_basicsize */
2289 0, /* tp_itemsize */
2290 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2291#if PY_VERSION_HEX < 0x030800b4
2292 (printfunc)0, /*tp_print*/
2293#else
2294 (Py_ssize_t)0, /*tp_vectorcall_offset*/
2295#endif
2296 (getattrfunc)0, /* tp_getattr */
2297 (setattrfunc)0, /* tp_setattr */
2298#if PY_VERSION_HEX>=0x03000000
2299 0, /* tp_reserved in 3.0.1 */
2300#else
2301 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2302#endif
2303 (reprfunc)SwigPyPacked_repr, /* tp_repr */
2304 0, /* tp_as_number */
2305 0, /* tp_as_sequence */
2306 0, /* tp_as_mapping */
2307 (hashfunc)0, /* tp_hash */
2308 (ternaryfunc)0, /* tp_call */
2309 (reprfunc)SwigPyPacked_str, /* tp_str */
2310 PyObject_GenericGetAttr, /* tp_getattro */
2311 0, /* tp_setattro */
2312 0, /* tp_as_buffer */
2313 Py_TPFLAGS_DEFAULT, /* tp_flags */
2314 swigpacked_doc, /* tp_doc */
2315 0, /* tp_traverse */
2316 0, /* tp_clear */
2317 0, /* tp_richcompare */
2318 0, /* tp_weaklistoffset */
2319 0, /* tp_iter */
2320 0, /* tp_iternext */
2321 0, /* tp_methods */
2322 0, /* tp_members */
2323 0, /* tp_getset */
2324 0, /* tp_base */
2325 0, /* tp_dict */
2326 0, /* tp_descr_get */
2327 0, /* tp_descr_set */
2328 0, /* tp_dictoffset */
2329 0, /* tp_init */
2330 0, /* tp_alloc */
2331 0, /* tp_new */
2332 0, /* tp_free */
2333 0, /* tp_is_gc */
2334 0, /* tp_bases */
2335 0, /* tp_mro */
2336 0, /* tp_cache */
2337 0, /* tp_subclasses */
2338 0, /* tp_weaklist */
2339 0, /* tp_del */
2340 0, /* tp_version_tag */
2341#if PY_VERSION_HEX >= 0x03040000
2342 0, /* tp_finalize */
2343#endif
2344#if PY_VERSION_HEX >= 0x03080000
2345 0, /* tp_vectorcall */
2346#endif
2347#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2348 0, /* tp_print */
2349#endif
2350#if PY_VERSION_HEX >= 0x030C0000
2351 0, /* tp_watched */
2352#endif
2353#ifdef COUNT_ALLOCS
2354 0, /* tp_allocs */
2355 0, /* tp_frees */
2356 0, /* tp_maxalloc */
2357 0, /* tp_prev */
2358 0 /* tp_next */
2359#endif
2360 };
2361 swigpypacked_type = tmp;
2362 type_init = 1;
2363 if (PyType_Ready(&swigpypacked_type) != 0)
2364 return NULL;
2365 }
2366 return &swigpypacked_type;
2367#else
2368 PyType_Slot slots[] = {
2369 { Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
2370 { Py_tp_repr, (void *)SwigPyPacked_repr },
2371 { Py_tp_str, (void *)SwigPyPacked_str },
2372 { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
2373 { Py_tp_doc, (void *)swigpacked_doc },
2374 { 0, NULL }
2375 };
2376 PyType_Spec spec = {
2377 "SwigPyPacked",
2378 sizeof(SwigPyPacked),
2379 0,
2380 Py_TPFLAGS_DEFAULT,
2381 slots
2382 };
2383 return (PyTypeObject *)PyType_FromSpec(&spec);
2384#endif
2385}
2386
2387SWIGRUNTIME PyObject *
2388SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2389{
2390 SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_type());
2391 if (sobj) {
2392 void *pack = malloc(size);
2393 if (pack) {
2394 memcpy(pack, ptr, size);
2395 sobj->pack = pack;
2396 sobj->ty = ty;
2397 sobj->size = size;
2398 } else {
2399 PyObject_DEL((PyObject *) sobj);
2400 sobj = 0;
2401 }
2402 }
2403 return (PyObject *) sobj;
2404}
2405
2407SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2408{
2409 if (SwigPyPacked_Check(obj)) {
2410 SwigPyPacked *sobj = (SwigPyPacked *)obj;
2411 if (sobj->size != size) return 0;
2412 memcpy(ptr, sobj->pack, size);
2413 return sobj->ty;
2414 } else {
2415 return 0;
2416 }
2417}
2418
2419/* -----------------------------------------------------------------------------
2420 * pointers/data manipulation
2421 * ----------------------------------------------------------------------------- */
2422
2423static PyObject *Swig_This_global = NULL;
2424
2425SWIGRUNTIME PyObject *
2427{
2428 if (Swig_This_global == NULL)
2430 return Swig_This_global;
2431}
2432
2433/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2434
2435/* TODO: I don't know how to implement the fast getset in Python 3 right now */
2436#if PY_VERSION_HEX>=0x03000000
2437#define SWIG_PYTHON_SLOW_GETSET_THIS
2438#endif
2439
2442{
2443 PyObject *obj;
2444
2445 if (SwigPyObject_Check(pyobj))
2446 return (SwigPyObject *) pyobj;
2447
2448#ifdef SWIGPYTHON_BUILTIN
2449 (void)obj;
2450# ifdef PyWeakref_CheckProxy
2451 if (PyWeakref_CheckProxy(pyobj)) {
2452#if PY_VERSION_HEX >= 0x030D0000
2453 PyWeakref_GetRef(pyobj, &pyobj);
2454 Py_DECREF(pyobj);
2455#else
2456 pyobj = PyWeakref_GET_OBJECT(pyobj);
2457#endif
2458 if (pyobj && SwigPyObject_Check(pyobj))
2459 return (SwigPyObject*) pyobj;
2460 }
2461# endif
2462 return NULL;
2463#else
2464
2465 obj = 0;
2466
2467#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2468 if (PyInstance_Check(pyobj)) {
2469 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2470 } else {
2471 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2472 if (dictptr != NULL) {
2473 PyObject *dict = *dictptr;
2474 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2475 } else {
2476#ifdef PyWeakref_CheckProxy
2477 if (PyWeakref_CheckProxy(pyobj)) {
2478 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2479 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2480 }
2481#endif
2482 obj = PyObject_GetAttr(pyobj,SWIG_This());
2483 if (obj) {
2484 Py_DECREF(obj);
2485 } else {
2486 if (PyErr_Occurred()) PyErr_Clear();
2487 return 0;
2488 }
2489 }
2490 }
2491#else
2492 obj = PyObject_GetAttr(pyobj,SWIG_This());
2493 if (obj) {
2494 Py_DECREF(obj);
2495 } else {
2496 if (PyErr_Occurred()) PyErr_Clear();
2497 return 0;
2498 }
2499#endif
2500 if (obj && !SwigPyObject_Check(obj)) {
2501 /* a PyObject is called 'this', try to get the 'real this'
2502 SwigPyObject from it */
2503 return SWIG_Python_GetSwigThis(obj);
2504 }
2505 return (SwigPyObject *)obj;
2506#endif
2507}
2508
2509/* Acquire a pointer value */
2510
2511SWIGRUNTIME int
2512SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2513 if (own == SWIG_POINTER_OWN) {
2515 if (sobj) {
2516 int oldown = sobj->own;
2517 sobj->own = own;
2518 return oldown;
2519 }
2520 }
2521 return 0;
2522}
2523
2524/* Convert a pointer value */
2525
2526SWIGRUNTIME int
2527SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2528 int res;
2529 SwigPyObject *sobj;
2530 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2531
2532 if (!obj)
2533 return SWIG_ERROR;
2534 if (obj == Py_None && !implicit_conv) {
2535 if (ptr)
2536 *ptr = 0;
2538 }
2539
2540 res = SWIG_ERROR;
2541
2542 sobj = SWIG_Python_GetSwigThis(obj);
2543 if (own)
2544 *own = 0;
2545 while (sobj) {
2546 void *vptr = sobj->ptr;
2547 if (ty) {
2548 swig_type_info *to = sobj->ty;
2549 if (to == ty) {
2550 /* no type cast needed */
2551 if (ptr) *ptr = vptr;
2552 break;
2553 } else {
2554 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2555 if (!tc) {
2556 sobj = (SwigPyObject *)sobj->next;
2557 } else {
2558 if (ptr) {
2559 int newmemory = 0;
2560 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2561 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2562 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2563 if (own)
2564 *own = *own | SWIG_CAST_NEW_MEMORY;
2565 }
2566 }
2567 break;
2568 }
2569 }
2570 } else {
2571 if (ptr) *ptr = vptr;
2572 break;
2573 }
2574 }
2575 if (sobj) {
2576 if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
2578 } else {
2579 if (own)
2580 *own = *own | sobj->own;
2581 if (flags & SWIG_POINTER_DISOWN) {
2582 sobj->own = 0;
2583 }
2584 if (flags & SWIG_POINTER_CLEAR) {
2585 sobj->ptr = 0;
2586 }
2587 res = SWIG_OK;
2588 }
2589 } else {
2590 if (implicit_conv) {
2591 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2592 if (data && !data->implicitconv) {
2593 PyObject *klass = data->klass;
2594 if (klass) {
2595 PyObject *impconv;
2596 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2597 impconv = SWIG_Python_CallFunctor(klass, obj);
2598 data->implicitconv = 0;
2599 if (PyErr_Occurred()) {
2600 PyErr_Clear();
2601 impconv = 0;
2602 }
2603 if (impconv) {
2604 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2605 if (iobj) {
2606 void *vptr;
2607 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2608 if (SWIG_IsOK(res)) {
2609 if (ptr) {
2610 *ptr = vptr;
2611 /* transfer the ownership to 'ptr' */
2612 iobj->own = 0;
2613 res = SWIG_AddCast(res);
2614 res = SWIG_AddNewMask(res);
2615 } else {
2616 res = SWIG_AddCast(res);
2617 }
2618 }
2619 }
2620 Py_DECREF(impconv);
2621 }
2622 }
2623 }
2624 if (!SWIG_IsOK(res) && obj == Py_None) {
2625 if (ptr)
2626 *ptr = 0;
2627 if (PyErr_Occurred())
2628 PyErr_Clear();
2629 res = SWIG_OK;
2630 }
2631 }
2632 }
2633 return res;
2634}
2635
2636/* Convert a function ptr value */
2637
2638SWIGRUNTIME int
2639SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2640 if (!PyCFunction_Check(obj)) {
2641 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2642 } else {
2643 void *vptr = 0;
2644 swig_cast_info *tc;
2645
2646 /* here we get the method pointer for callbacks */
2647#ifndef Py_LIMITED_API
2648 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2649#else
2650 PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
2651 PyObject *bytes = NULL;
2652 const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
2653#endif
2654 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2655 if (desc)
2656 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2657#ifdef Py_LIMITED_API
2658 Py_XDECREF(bytes);
2659 Py_XDECREF(pystr_doc);
2660#endif
2661 if (!desc)
2662 return SWIG_ERROR;
2663 tc = SWIG_TypeCheck(desc,ty);
2664 if (tc) {
2665 int newmemory = 0;
2666 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2667 assert(!newmemory); /* newmemory handling not yet implemented */
2668 } else {
2669 return SWIG_ERROR;
2670 }
2671 return SWIG_OK;
2672 }
2673}
2674
2675/* Convert a packed pointer value */
2676
2677SWIGRUNTIME int
2678SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2679 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2680 if (!to) return SWIG_ERROR;
2681 if (ty) {
2682 if (to != ty) {
2683 /* check type cast? */
2684 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2685 if (!tc) return SWIG_ERROR;
2686 }
2687 }
2688 return SWIG_OK;
2689}
2690
2691/* -----------------------------------------------------------------------------
2692 * Create a new pointer object
2693 * ----------------------------------------------------------------------------- */
2694
2695/*
2696 Create a new instance object, without calling __init__, and set the
2697 'this' attribute.
2698*/
2699
2700SWIGRUNTIME PyObject*
2702{
2703 PyObject *inst = 0;
2704 PyObject *newraw = data->newraw;
2705 if (newraw) {
2706 inst = PyObject_Call(newraw, data->newargs, NULL);
2707 if (inst) {
2708#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2709 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2710 if (dictptr != NULL) {
2711 PyObject *dict = *dictptr;
2712 if (dict == NULL) {
2713 dict = PyDict_New();
2714 *dictptr = dict;
2715 }
2716 if (dict) {
2717 PyDict_SetItem(dict, SWIG_This(), swig_this);
2718 } else{
2719 Py_DECREF(inst);
2720 inst = 0;
2721 }
2722 }
2723#else
2724 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2725 Py_DECREF(inst);
2726 inst = 0;
2727 }
2728#endif
2729 }
2730 } else {
2731#if PY_VERSION_HEX >= 0x03000000
2732 PyObject *empty_args = PyTuple_New(0);
2733 if (empty_args) {
2734 PyObject *empty_kwargs = PyDict_New();
2735 if (empty_kwargs) {
2736#ifndef Py_LIMITED_API
2737 newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
2738#else
2739 newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
2740#endif
2741 inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
2742 Py_DECREF(empty_kwargs);
2743 if (inst) {
2744 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2745 Py_DECREF(inst);
2746 inst = 0;
2747 } else {
2748 PyType_Modified(Py_TYPE(inst));
2749 }
2750 }
2751 }
2752 Py_DECREF(empty_args);
2753 }
2754#else
2755 PyObject *dict = PyDict_New();
2756 if (dict) {
2757 PyDict_SetItem(dict, SWIG_This(), swig_this);
2758 inst = PyInstance_NewRaw(data->newargs, dict);
2759 Py_DECREF(dict);
2760 }
2761#endif
2762 }
2763 return inst;
2764}
2765
2766SWIGRUNTIME int
2767SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2768{
2769#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2770 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2771 if (dictptr != NULL) {
2772 PyObject *dict = *dictptr;
2773 if (dict == NULL) {
2774 dict = PyDict_New();
2775 *dictptr = dict;
2776 }
2777 if (dict) {
2778 return PyDict_SetItem(dict, SWIG_This(), swig_this);
2779 } else{
2780 return -1;
2781 }
2782 }
2783#endif
2784 return PyObject_SetAttr(inst, SWIG_This(), swig_this);
2785}
2786
2787
2788SWIGINTERN PyObject *
2790 PyObject *obj[2];
2791 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2792 return NULL;
2793 } else {
2794 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2795 if (sthis) {
2796 Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
2797 } else {
2798 if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
2799 return NULL;
2800 }
2801 return SWIG_Py_Void();
2802 }
2803}
2804
2805/* Create a new pointer object */
2806
2807SWIGRUNTIME PyObject *
2808SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2809 SwigPyClientData *clientdata;
2810 PyObject * robj;
2811 int own;
2812
2813 if (!ptr)
2814 return SWIG_Py_Void();
2815
2816 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2817 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2818 if (clientdata && clientdata->pytype) {
2819 SwigPyObject *newobj;
2820 if (flags & SWIG_BUILTIN_TP_INIT) {
2821 newobj = (SwigPyObject*) self;
2822 if (newobj->ptr) {
2823#ifndef Py_LIMITED_API
2824 allocfunc alloc = clientdata->pytype->tp_alloc;
2825#else
2826 allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
2827#endif
2828 PyObject *next_self = alloc(clientdata->pytype, 0);
2829 while (newobj->next)
2830 newobj = (SwigPyObject *) newobj->next;
2831 newobj->next = next_self;
2832 newobj = (SwigPyObject *)next_self;
2833#ifdef SWIGPYTHON_BUILTIN
2834 newobj->dict = 0;
2835#endif
2836 }
2837 } else {
2838 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2839#ifdef SWIGPYTHON_BUILTIN
2840 if (newobj) {
2841 newobj->dict = 0;
2842 }
2843#endif
2844 }
2845 if (newobj) {
2846 newobj->ptr = ptr;
2847 newobj->ty = type;
2848 newobj->own = own;
2849 newobj->next = 0;
2850 return (PyObject*) newobj;
2851 }
2852 return SWIG_Py_Void();
2853 }
2854
2855 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2856
2857 robj = SwigPyObject_New(ptr, type, own);
2858 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2859 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2860 Py_DECREF(robj);
2861 robj = inst;
2862 }
2863 return robj;
2864}
2865
2866/* Create a new packed object */
2867
2868SWIGRUNTIMEINLINE PyObject *
2869SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2870 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2871}
2872
2873/* -----------------------------------------------------------------------------*
2874 * Get type list
2875 * -----------------------------------------------------------------------------*/
2876
2877#ifdef SWIG_LINK_RUNTIME
2878void *SWIG_ReturnGlobalTypeList(void *);
2879#endif
2880
2881static PyObject *Swig_TypeCache_global = NULL;
2882
2883/* The python cached type query */
2884SWIGRUNTIME PyObject *
2886 if (Swig_TypeCache_global == NULL) {
2887 Swig_TypeCache_global = PyDict_New();
2888 }
2889 return Swig_TypeCache_global;
2890}
2891
2894#ifdef SWIG_LINK_RUNTIME
2895 static void *type_pointer = (void *)0;
2896 /* first check if module already created */
2897 if (!type_pointer) {
2898 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2899 }
2900#else
2901 void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2902 if (PyErr_Occurred()) {
2903 PyErr_Clear();
2904 type_pointer = (void *)0;
2905 }
2906#endif
2907 return (swig_module_info *) type_pointer;
2908}
2909
2910
2911static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */
2912
2913SWIGRUNTIME void
2915{
2916 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2917 swig_type_info **types = swig_module->types;
2918 size_t i;
2919 if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
2920 return;
2921 for (i =0; i < swig_module->size; ++i) {
2922 swig_type_info *ty = types[i];
2923 if (ty->owndata) {
2925 ty->clientdata = 0;
2926 if (data) SwigPyClientData_Del(data);
2927 }
2928 }
2929 Py_DECREF(SWIG_This());
2930 Swig_This_global = NULL;
2931 Py_DECREF(SWIG_globals());
2932 Swig_Globals_global = NULL;
2933 Py_DECREF(SWIG_Python_TypeCache());
2934 Swig_TypeCache_global = NULL;
2935 Swig_Capsule_global = NULL;
2936}
2937
2938SWIGRUNTIME void
2940#if PY_VERSION_HEX >= 0x03000000
2941 /* Add a dummy module object into sys.modules */
2942 PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2943#else
2944 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2945 PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2946#endif
2947 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2948 if (pointer && module) {
2949 if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
2951 Swig_Capsule_global = pointer;
2952 } else {
2953 Py_DECREF(pointer);
2954 }
2955 } else {
2956 Py_XDECREF(pointer);
2957 }
2958}
2959
2961SWIG_Python_TypeQuery(const char *type)
2962{
2963 PyObject *cache = SWIG_Python_TypeCache();
2964 PyObject *key = SWIG_Python_str_FromChar(type);
2965 PyObject *obj = PyDict_GetItem(cache, key);
2966 swig_type_info *descriptor;
2967 if (obj) {
2968 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2969 } else {
2971 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2972 if (descriptor) {
2973 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2974 if (obj) {
2975 PyDict_SetItem(cache, key, obj);
2976 Py_DECREF(obj);
2977 }
2978 }
2979 }
2980 Py_DECREF(key);
2981 return descriptor;
2982}
2983
2984/*
2985 For backward compatibility only
2986*/
2987#define SWIG_POINTER_EXCEPTION 0
2988#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2989#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2990
2991SWIGRUNTIME int
2992SWIG_Python_AddErrMesg(const char* mesg, int infront)
2993{
2994 if (PyErr_Occurred()) {
2995 PyObject *type = 0;
2996 PyObject *value = 0;
2997 PyObject *traceback = 0;
2998 PyErr_Fetch(&type, &value, &traceback);
2999 if (value) {
3000 PyObject *old_str = PyObject_Str(value);
3001 PyObject *bytes = NULL;
3002 const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
3003 const char *errmesg = tmp ? tmp : "Invalid error message";
3004 Py_XINCREF(type);
3005 PyErr_Clear();
3006 if (infront) {
3007 PyErr_Format(type, "%s %s", mesg, errmesg);
3008 } else {
3009 PyErr_Format(type, "%s %s", errmesg, mesg);
3010 }
3011 Py_XDECREF(bytes);
3012 Py_DECREF(old_str);
3013 }
3014 return 1;
3015 } else {
3016 return 0;
3017 }
3018}
3019
3020SWIGRUNTIME int
3022{
3023 if (PyErr_Occurred()) {
3024 /* add information about failing argument */
3025 char mesg[256];
3026 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
3027 return SWIG_Python_AddErrMesg(mesg, 1);
3028 } else {
3029 return 0;
3030 }
3031}
3032
3033SWIGRUNTIMEINLINE const char *
3035{
3036 SwigPyObject *v = (SwigPyObject *)self;
3037 swig_type_info *ty = v ? v->ty : 0;
3038 return ty ? ty->str : "";
3039}
3040
3041SWIGRUNTIME void
3042SWIG_Python_TypeError(const char *type, PyObject *obj)
3043{
3044 if (type) {
3045#if defined(SWIG_COBJECT_TYPES)
3046 if (obj && SwigPyObject_Check(obj)) {
3047 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
3048 if (otype) {
3049 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
3050 type, otype);
3051 return;
3052 }
3053 } else
3054#endif
3055 {
3056#ifndef Py_LIMITED_API
3057 /* tp_name is not accessible */
3058 const char *otype = (obj ? obj->ob_type->tp_name : 0);
3059 if (otype) {
3060 PyObject *str = PyObject_Str(obj);
3061 PyObject *bytes = NULL;
3062 const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0;
3063 if (cstr) {
3064 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
3065 type, otype, cstr);
3066 } else {
3067 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
3068 type, otype);
3069 }
3070 Py_XDECREF(bytes);
3071 Py_XDECREF(str);
3072 return;
3073 }
3074#endif
3075 }
3076 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
3077 } else {
3078 PyErr_Format(PyExc_TypeError, "unexpected type is received");
3079 }
3080}
3081
3082
3083/* Convert a pointer value, signal an exception on a type mismatch */
3084SWIGRUNTIME void *
3085SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
3086 void *result;
3087 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
3088 PyErr_Clear();
3089 }
3090 return result;
3091}
3092
3093#ifdef SWIGPYTHON_BUILTIN
3094SWIGRUNTIME int
3095SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
3096 PyTypeObject *tp = obj->ob_type;
3097 PyObject *descr;
3098 PyObject *encoded_name;
3099 descrsetfunc f;
3100 int res = -1;
3101
3102# ifdef Py_USING_UNICODE
3103 if (PyString_Check(name)) {
3104 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
3105 if (!name)
3106 return -1;
3107 } else if (!PyUnicode_Check(name))
3108# else
3109 if (!PyString_Check(name))
3110# endif
3111 {
3112 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
3113 return -1;
3114 } else {
3115 Py_INCREF(name);
3116 }
3117
3118 if (!tp->tp_dict) {
3119 if (PyType_Ready(tp) != 0)
3120 goto done;
3121 }
3122
3123 descr = _PyType_Lookup(tp, name);
3124 f = NULL;
3125 if (descr != NULL)
3126 f = descr->ob_type->tp_descr_set;
3127 if (!f) {
3128 if (PyString_Check(name)) {
3129 encoded_name = name;
3130 Py_INCREF(name);
3131 } else {
3132 encoded_name = PyUnicode_AsUTF8String(name);
3133 if (!encoded_name)
3134 goto done;
3135 }
3136 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
3137 Py_DECREF(encoded_name);
3138 } else {
3139 res = f(descr, obj, value);
3140 }
3141
3142 done:
3143 Py_DECREF(name);
3144 return res;
3145}
3146#endif
3147
3148
3149#ifdef __cplusplus
3150}
3151#endif
3152
3153
3154
3155#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3156
3157#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
3158
3159
3160
3161/* -------- TYPES TABLE (BEGIN) -------- */
3162
3163#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
3164#define SWIGTYPE_p_PLcGrid swig_types[1]
3165#define SWIGTYPE_p_PLcGrid2 swig_types[2]
3166#define SWIGTYPE_p_char swig_types[3]
3167#define SWIGTYPE_p_double swig_types[4]
3168#define SWIGTYPE_p_f_double_double__int swig_types[5]
3169#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
3170#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
3171#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
3172#define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
3173#define SWIGTYPE_p_int swig_types[10]
3174#define SWIGTYPE_p_p_char swig_types[11]
3175#define SWIGTYPE_p_p_double swig_types[12]
3176#define SWIGTYPE_p_unsigned_int swig_types[13]
3178static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
3179#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3180#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3181
3182/* -------- TYPES TABLE (END) -------- */
3183
3184#ifdef SWIG_TypeQuery
3185# undef SWIG_TypeQuery
3186#endif
3187#define SWIG_TypeQuery SWIG_Python_TypeQuery
3188
3189/*-----------------------------------------------
3190 @(target):= _plplotc.so
3191 ------------------------------------------------*/
3192#if PY_VERSION_HEX >= 0x03000000
3193# define SWIG_init PyInit__plplotc
3194
3195#else
3196# define SWIG_init init_plplotc
3197
3198#endif
3199#define SWIG_name "_plplotc"
3200
3201#define SWIG_as_voidptr(a) (void *)((const void *)(a))
3202#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3203
3204
3205#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
3206#include <arrayobject.h>
3207#include "plplot.h"
3208#include "plplotP.h"
3209
3210#define NPY_PLINT NPY_INT32
3211
3212#ifdef PL_DOUBLE
3213#define NPY_PLFLT NPY_FLOAT64
3214#else
3215#define NPY_PLFLT NPY_FLOAT32
3216#endif
3217
3218// python-1.5 compatibility mode?
3219#if !defined ( PySequence_Fast_GET_ITEM )
3220 #define PySequence_Fast_GET_ITEM PySequence_GetItem
3221#endif
3222#define PySequence_Size PySequence_Length
3223
3224
3225 static PLINT Alen = 0;
3226 static PLINT Xlen = 0, Ylen = 0;
3227
3228
3229SWIGINTERN int
3230SWIG_AsVal_double (PyObject *obj, double *val)
3231{
3232 int res = SWIG_TypeError;
3233 if (PyFloat_Check(obj)) {
3234 if (val) *val = PyFloat_AsDouble(obj);
3235 return SWIG_OK;
3236#if PY_VERSION_HEX < 0x03000000
3237 } else if (PyInt_Check(obj)) {
3238 if (val) *val = (double) PyInt_AsLong(obj);
3239 return SWIG_OK;
3240#endif
3241 } else if (PyLong_Check(obj)) {
3242 double v = PyLong_AsDouble(obj);
3243 if (!PyErr_Occurred()) {
3244 if (val) *val = v;
3245 return SWIG_OK;
3246 } else {
3247 PyErr_Clear();
3248 }
3249 }
3250#ifdef SWIG_PYTHON_CAST_MODE
3251 {
3252 int dispatch = 0;
3253 double d = PyFloat_AsDouble(obj);
3254 if (!PyErr_Occurred()) {
3255 if (val) *val = d;
3256 return SWIG_AddCast(SWIG_OK);
3257 } else {
3258 PyErr_Clear();
3259 }
3260 if (!dispatch) {
3261 long v = PyLong_AsLong(obj);
3262 if (!PyErr_Occurred()) {
3263 if (val) *val = v;
3265 } else {
3266 PyErr_Clear();
3267 }
3268 }
3269 }
3270#endif
3271 return res;
3272}
3273
3274
3275 #define SWIG_From_double PyFloat_FromDouble
3276
3277
3278 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3279 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3280 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3281 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3282 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3284 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3285
3286
3287SWIGINTERNINLINE PyObject*
3289{
3290 return PyInt_FromLong((long) value);
3291}
3292
3293
3294#include <limits.h>
3295#if !defined(SWIG_NO_LLONG_MAX)
3296# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3297# define LLONG_MAX __LONG_LONG_MAX__
3298# define LLONG_MIN (-LLONG_MAX - 1LL)
3299# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3300# endif
3301#endif
3302
3303
3304#include <float.h>
3305
3306
3307#include <math.h>
3308
3309
3311SWIG_CanCastAsInteger(double *d, double min, double max) {
3312 double x = *d;
3313 if ((min <= x && x <= max)) {
3314 double fx, cx, rd;
3315 errno = 0;
3316 fx = floor(x);
3317 cx = ceil(x);
3318 rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3319 if ((errno == EDOM) || (errno == ERANGE)) {
3320 errno = 0;
3321 } else {
3322 double summ, reps, diff;
3323 if (rd < x) {
3324 diff = x - rd;
3325 } else if (rd > x) {
3326 diff = rd - x;
3327 } else {
3328 return 1;
3329 }
3330 summ = rd + x;
3331 reps = diff/summ;
3332 if (reps < 8*DBL_EPSILON) {
3333 *d = rd;
3334 return 1;
3335 }
3336 }
3337 }
3338 return 0;
3339}
3340
3341
3342SWIGINTERN int
3343SWIG_AsVal_long (PyObject *obj, long* val)
3344{
3345#if PY_VERSION_HEX < 0x03000000
3346 if (PyInt_Check(obj)) {
3347 if (val) *val = PyInt_AsLong(obj);
3348 return SWIG_OK;
3349 } else
3350#endif
3351 if (PyLong_Check(obj)) {
3352 long v = PyLong_AsLong(obj);
3353 if (!PyErr_Occurred()) {
3354 if (val) *val = v;
3355 return SWIG_OK;
3356 } else {
3357 PyErr_Clear();
3358 return SWIG_OverflowError;
3359 }
3360 }
3361#ifdef SWIG_PYTHON_CAST_MODE
3362 {
3363 int dispatch = 0;
3364 long v = PyInt_AsLong(obj);
3365 if (!PyErr_Occurred()) {
3366 if (val) *val = v;
3367 return SWIG_AddCast(SWIG_OK);
3368 } else {
3369 PyErr_Clear();
3370 }
3371 if (!dispatch) {
3372 double d;
3373 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3374 // Largest double not larger than LONG_MAX (not portably calculated easily)
3375 // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
3376 // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
3377 const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
3378 // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
3379 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
3380 if (val) *val = (long)(d);
3381 return res;
3382 }
3383 }
3384 }
3385#endif
3386 return SWIG_TypeError;
3387}
3388
3389
3390SWIGINTERN int
3391SWIG_AsVal_int (PyObject * obj, int *val)
3392{
3393 long v;
3394 int res = SWIG_AsVal_long (obj, &v);
3395 if (SWIG_IsOK(res)) {
3396 if ((v < INT_MIN || v > INT_MAX)) {
3397 return SWIG_OverflowError;
3398 } else {
3399 if (val) *val = (int)(v);
3400 }
3401 }
3402 return res;
3403}
3404
3405
3406SWIGINTERN int
3407SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3408{
3409#if PY_VERSION_HEX < 0x03000000
3410 if (PyInt_Check(obj)) {
3411 long v = PyInt_AsLong(obj);
3412 if (v >= 0) {
3413 if (val) *val = v;
3414 return SWIG_OK;
3415 } else {
3416 return SWIG_OverflowError;
3417 }
3418 } else
3419#endif
3420 if (PyLong_Check(obj)) {
3421 unsigned long v = PyLong_AsUnsignedLong(obj);
3422 if (!PyErr_Occurred()) {
3423 if (val) *val = v;
3424 return SWIG_OK;
3425 } else {
3426 PyErr_Clear();
3427 return SWIG_OverflowError;
3428 }
3429 }
3430#ifdef SWIG_PYTHON_CAST_MODE
3431 {
3432 int dispatch = 0;
3433 unsigned long v = PyLong_AsUnsignedLong(obj);
3434 if (!PyErr_Occurred()) {
3435 if (val) *val = v;
3436 return SWIG_AddCast(SWIG_OK);
3437 } else {
3438 PyErr_Clear();
3439 }
3440 if (!dispatch) {
3441 double d;
3442 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3443 // Largest double not larger than ULONG_MAX (not portably calculated easily)
3444 // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
3445 // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
3446 const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
3447 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
3448 if (val) *val = (unsigned long)(d);
3449 return res;
3450 }
3451 }
3452 }
3453#endif
3454 return SWIG_TypeError;
3455}
3456
3457
3458SWIGINTERN int
3459SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3460{
3461 unsigned long v;
3462 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3463 if (SWIG_IsOK(res)) {
3464 if ((v > UINT_MAX)) {
3465 return SWIG_OverflowError;
3466 } else {
3467 if (val) *val = (unsigned int)(v);
3468 }
3469 }
3470 return res;
3471}
3472
3473
3474SWIGINTERNINLINE PyObject*
3476{
3477 return PyInt_FromSize_t((size_t) value);
3478}
3479
3480
3483{
3484 static int init = 0;
3485 static swig_type_info* info = 0;
3486 if (!init) {
3487 info = SWIG_TypeQuery("_p_char");
3488 init = 1;
3489 }
3490 return info;
3491}
3492
3493
3494/* Return string from Python obj. NOTE: obj must remain in scope in order
3495 to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
3496SWIGINTERN int
3497SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
3498{
3499#if PY_VERSION_HEX>=0x03000000
3500#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3501 if (PyBytes_Check(obj))
3502#else
3503 if (PyUnicode_Check(obj))
3504#endif
3505#else
3506 if (PyString_Check(obj))
3507#endif
3508 {
3509 char *cstr; Py_ssize_t len;
3510 PyObject *bytes = NULL;
3511 int ret = SWIG_OK;
3512 if (alloc)
3513 *alloc = SWIG_OLDOBJ;
3514#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3515 if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
3516 return SWIG_TypeError;
3517#else
3518 cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
3519 if (!cstr)
3520 return SWIG_TypeError;
3521 /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
3522 if (bytes && cptr) {
3523 if (alloc) {
3524 cstr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3525 *alloc = SWIG_NEWOBJ;
3526 } else {
3527 /* alloc must be set in order to clean up allocated memory */
3528 return SWIG_RuntimeError;
3529 }
3530 }
3531#endif
3532 if (cptr) *cptr = cstr;
3533 if (psize) *psize = len + 1;
3534 Py_XDECREF(bytes);
3535 return ret;
3536 } else {
3537#if defined(SWIG_PYTHON_2_UNICODE)
3538#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3539#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3540#endif
3541#if PY_VERSION_HEX<0x03000000
3542 if (PyUnicode_Check(obj)) {
3543 char *cstr; Py_ssize_t len;
3544 if (!alloc && cptr) {
3545 return SWIG_RuntimeError;
3546 }
3547 obj = PyUnicode_AsUTF8String(obj);
3548 if (!obj)
3549 return SWIG_TypeError;
3550 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3551 if (cptr) {
3552 if (alloc) *alloc = SWIG_NEWOBJ;
3553 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3554 }
3555 if (psize) *psize = len + 1;
3556
3557 Py_XDECREF(obj);
3558 return SWIG_OK;
3559 } else {
3560 Py_XDECREF(obj);
3561 }
3562 }
3563#endif
3564#endif
3565
3566 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3567 if (pchar_descriptor) {
3568 void* vptr = 0;
3569 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3570 if (cptr) *cptr = (char *) vptr;
3571 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3572 if (alloc) *alloc = SWIG_OLDOBJ;
3573 return SWIG_OK;
3574 }
3575 }
3576 }
3577 return SWIG_TypeError;
3578}
3579
3580
3581SWIGINTERN int
3582SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3583{
3584 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3585 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3586 if (SWIG_IsOK(res)) {
3587 /* special case of single char conversion when we don't need space for NUL */
3588 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3589 if (csize <= size) {
3590 if (val) {
3591 if (csize) memcpy(val, cptr, csize*sizeof(char));
3592 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3593 }
3594 if (alloc == SWIG_NEWOBJ) {
3595 free((char*)cptr);
3596 res = SWIG_DelNewMask(res);
3597 }
3598 return res;
3599 }
3600 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3601 }
3602 return SWIG_TypeError;
3603}
3604
3605
3606SWIGINTERNINLINE PyObject *
3607SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3608{
3609 if (carray) {
3610 if (size > INT_MAX) {
3611 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3612 return pchar_descriptor ?
3613 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3614 } else {
3615#if PY_VERSION_HEX >= 0x03000000
3616#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3617 return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3618#else
3619 return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3620#endif
3621#else
3622 return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3623#endif
3624 }
3625 } else {
3626 return SWIG_Py_Void();
3627 }
3628}
3629
3630
3631SWIGINTERN size_t
3632SWIG_strnlen(const char* s, size_t maxlen)
3633{
3634 const char *p;
3635 for (p = s; maxlen-- && *p; p++)
3636 ;
3637 return p - s;
3638}
3639
3640
3641
3642
3643
3644SWIGINTERN int
3645SWIG_AsVal_char (PyObject * obj, char *val)
3646{
3647 int res = SWIG_AsCharArray(obj, val, 1);
3648 if (!SWIG_IsOK(res)) {
3649 long v;
3650 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3651 if (SWIG_IsOK(res)) {
3652 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3653 if (val) *val = (char)(v);
3654 } else {
3655 res = SWIG_OverflowError;
3656 }
3657 }
3658 }
3659 return res;
3660}
3661
3662#ifdef __cplusplus
3663extern "C" {
3664#endif
3665
3666 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3667
3668// some really twisted stuff to allow calling a single precision library from python
3669 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3670 {
3671 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3672 mindims, maxdims );
3673 if ( !tmp )
3674 {
3675 // could be an incoming long array which can't be "safely" converted, do it anyway
3676 if ( PyArray_Check( in ) )
3677 {
3678 PyErr_Clear();
3679 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3680 }
3681 }
3682 return tmp;
3683 }
3684
3685
3686#define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3687
3688SWIGINTERN PyObject *_wrap_pltr0(PyObject *self, PyObject *args) {
3689 PyObject *resultobj = 0;
3690 PLFLT arg1 ;
3691 PLFLT arg2 ;
3692 PLFLT *arg3 = (PLFLT *) 0 ;
3693 PLFLT *arg4 = (PLFLT *) 0 ;
3694 PLPointer arg5 = (PLPointer) 0 ;
3695 double val1 ;
3696 int ecode1 = 0 ;
3697 double val2 ;
3698 int ecode2 = 0 ;
3699 PLFLT temp3 ;
3700 int res3 = SWIG_TMPOBJ ;
3701 PLFLT temp4 ;
3702 int res4 = SWIG_TMPOBJ ;
3703 PyObject *swig_obj[2] ;
3704
3705 arg3 = &temp3;
3706 arg4 = &temp4;
3707 {
3708 arg5 = NULL;
3709 }
3710 (void)self;
3711 if (!SWIG_Python_UnpackTuple(args, "pltr0", 2, 2, swig_obj)) SWIG_fail;
3712 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3713 if (!SWIG_IsOK(ecode1)) {
3714 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3715 }
3716 arg1 = (PLFLT)(val1);
3717 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3718 if (!SWIG_IsOK(ecode2)) {
3719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3720 }
3721 arg2 = (PLFLT)(val2);
3722 pltr0(arg1,arg2,arg3,arg4,arg5);
3723 resultobj = SWIG_Py_Void();
3724 if (SWIG_IsTmpObj(res3)) {
3725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3726 } else {
3727 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3729 }
3730 if (SWIG_IsTmpObj(res4)) {
3731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3732 } else {
3733 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3735 }
3736 return resultobj;
3737fail:
3738 return NULL;
3739}
3740
3741
3742
3743 PyArrayObject *pltr_xg, *pltr_yg;
3746
3747 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3748 void cleanup_PLcGrid1( void );
3749 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3750 void cleanup_PLcGrid2( void );
3751
3752 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3753 {
3754 // fprintf(stderr, "marshal PLcGrid1\n");
3755 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3756 {
3757 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3758 return NULL;
3759 }
3760 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3761 NPY_PLFLT, 1, 1 );
3762 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3763 NPY_PLFLT, 1, 1 );
3764 if ( pltr_xg == 0 || pltr_yg == 0 )
3765 {
3766 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3767 return NULL;
3768 }
3769 tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3770 tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3771 if ( isimg == 0 )
3772 {
3773 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3774 {
3775 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3776 return NULL;
3777 }
3778 }
3779 else
3780 {
3781 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3782 {
3783 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3784 return NULL;
3785 }
3786 }
3787 tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3788 tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3789 return &tmpGrid1;
3790 }
3791
3792 void cleanup_PLcGrid1( void )
3793 {
3794 // fprintf(stderr, "cleanup PLcGrid1\n");
3795 Py_CLEAR( pltr_xg );
3796 Py_CLEAR( pltr_yg );
3797 }
3798
3799 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3800 {
3801 int i, size;
3802 // fprintf(stderr, "marshal PLcGrid2\n");
3803 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3804 {
3805 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3806 return NULL;
3807 }
3808 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3809 NPY_PLFLT, 2, 2 );
3810 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3811 NPY_PLFLT, 2, 2 );
3812 if ( pltr_xg == 0 || pltr_yg == 0 )
3813 {
3814 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3815 return NULL;
3816 }
3817 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3818 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3819 {
3820 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3821 return NULL;
3822 }
3823 tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3824 tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3825 if ( isimg == 0 )
3826 {
3827 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3828 {
3829 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3830 return NULL;
3831 }
3832 }
3833 else
3834 {
3835 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3836 {
3837 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3838 return NULL;
3839 }
3840 }
3841 size = tmpGrid2.ny;
3842 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3843 for ( i = 0; i < tmpGrid2.nx; i++ )
3844 tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3845 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3846 for ( i = 0; i < tmpGrid2.nx; i++ )
3847 tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3848 return &tmpGrid2;
3849 }
3850
3851 void cleanup_PLcGrid2( void )
3852 {
3853 // fprintf(stderr, "cleanup PLcGrid2\n");
3854 free( tmpGrid2.xg );
3855 free( tmpGrid2.yg );
3856 Py_CLEAR( pltr_xg );
3857 Py_CLEAR( pltr_yg );
3858 }
3859
3860SWIGINTERN PyObject *_wrap_pltr1(PyObject *self, PyObject *args) {
3861 PyObject *resultobj = 0;
3862 PLFLT arg1 ;
3863 PLFLT arg2 ;
3864 PLFLT *arg3 = (PLFLT *) 0 ;
3865 PLFLT *arg4 = (PLFLT *) 0 ;
3866 PLcGrid *arg5 = (PLcGrid *) 0 ;
3867 double val1 ;
3868 int ecode1 = 0 ;
3869 double val2 ;
3870 int ecode2 = 0 ;
3871 PLFLT temp3 ;
3872 int res3 = SWIG_TMPOBJ ;
3873 PLFLT temp4 ;
3874 int res4 = SWIG_TMPOBJ ;
3875 PyObject *swig_obj[3] ;
3876
3877 arg3 = &temp3;
3878 arg4 = &temp4;
3879 (void)self;
3880 if (!SWIG_Python_UnpackTuple(args, "pltr1", 3, 3, swig_obj)) SWIG_fail;
3881 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3882 if (!SWIG_IsOK(ecode1)) {
3883 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3884 }
3885 arg1 = (PLFLT)(val1);
3886 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3887 if (!SWIG_IsOK(ecode2)) {
3888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3889 }
3890 arg2 = (PLFLT)(val2);
3891 {
3892 arg5 = marshal_PLcGrid1( swig_obj[2], 0 );
3893 if ( !arg5 )
3894 return NULL;
3895 }
3896 pltr1(arg1,arg2,arg3,arg4,arg5);
3897 resultobj = SWIG_Py_Void();
3898 if (SWIG_IsTmpObj(res3)) {
3899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3900 } else {
3901 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3903 }
3904 if (SWIG_IsTmpObj(res4)) {
3905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3906 } else {
3907 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3909 }
3910 {
3912 }
3913 return resultobj;
3914fail:
3915 {
3917 }
3918 return NULL;
3919}
3920
3921
3922SWIGINTERN PyObject *_wrap_pltr2(PyObject *self, PyObject *args) {
3923 PyObject *resultobj = 0;
3924 PLFLT arg1 ;
3925 PLFLT arg2 ;
3926 PLFLT *arg3 = (PLFLT *) 0 ;
3927 PLFLT *arg4 = (PLFLT *) 0 ;
3928 PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3929 double val1 ;
3930 int ecode1 = 0 ;
3931 double val2 ;
3932 int ecode2 = 0 ;
3933 PLFLT temp3 ;
3934 int res3 = SWIG_TMPOBJ ;
3935 PLFLT temp4 ;
3936 int res4 = SWIG_TMPOBJ ;
3937 PyObject *swig_obj[3] ;
3938
3939 arg3 = &temp3;
3940 arg4 = &temp4;
3941 (void)self;
3942 if (!SWIG_Python_UnpackTuple(args, "pltr2", 3, 3, swig_obj)) SWIG_fail;
3943 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3944 if (!SWIG_IsOK(ecode1)) {
3945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3946 }
3947 arg1 = (PLFLT)(val1);
3948 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3949 if (!SWIG_IsOK(ecode2)) {
3950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3951 }
3952 arg2 = (PLFLT)(val2);
3953 {
3954 arg5 = marshal_PLcGrid2( swig_obj[2], 0 );
3955 if ( !arg5 )
3956 return NULL;
3957 }
3958 pltr2(arg1,arg2,arg3,arg4,arg5);
3959 resultobj = SWIG_Py_Void();
3960 if (SWIG_IsTmpObj(res3)) {
3961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3962 } else {
3963 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3965 }
3966 if (SWIG_IsTmpObj(res4)) {
3967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3968 } else {
3969 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3971 }
3972 {
3974 }
3975 return resultobj;
3976fail:
3977 {
3979 }
3980 return NULL;
3981}
3982
3983
3984
3985 // helper code for handling the callback
3986#if 0
3987 static PyInterpreterState *save_interp = NULL;
3988#endif
3990 PyObject* python_pltr = NULL;
3991 PyObject* python_f2eval = NULL;
3992 PyObject* python_ct = NULL;
3993 PyObject* python_mapform = NULL;
3994 PyObject* python_label = NULL;
3995
3996#if 0
3997#define MY_BLOCK_THREADS { \
3998 PyThreadState *prev_state, *new_state; \
3999 /* need to have started a thread at some stage */ \
4000 /* for the following to work */ \
4001 PyEval_AcquireLock(); \
4002 new_state = PyThreadState_New( save_interp ); \
4003 prev_state = PyThreadState_Swap( new_state );
4004#define MY_UNBLOCK_THREADS \
4005 new_state = PyThreadState_Swap( prev_state ); \
4006 PyThreadState_Clear( new_state ); \
4007 PyEval_ReleaseLock(); \
4008 PyThreadState_Delete( new_state ); \
4009 }
4010#else
4011#define MY_BLOCK_THREADS
4012#define MY_UNBLOCK_THREADS
4013#endif
4014
4015// Function prototypes
4016 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
4018 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
4019 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
4020 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
4021 pltr_func marshal_pltr( PyObject* input );
4022 void cleanup_pltr( void );
4023 ct_func marshal_ct( PyObject* input );
4024 void cleanup_ct( void );
4025 mapform_func marshal_mapform( PyObject* input );
4026 void cleanup_mapform( void );
4027 PLPointer marshal_PLPointer( PyObject* input, int isimg );
4028 void cleanup_PLPointer( void );
4029
4030
4031// This is the callback that gets handed to the C code. It, in turn, calls the Python callback
4032
4033 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
4034 {
4035 PyObject *pdata, *arglist, *result;
4036 PyArrayObject *tmp;
4037
4038 // the data argument is acutally a pointer to a python object
4039 pdata = (PyObject *) data;
4040 if ( data == NULL )
4041 {
4042 pdata = Py_None;
4043 }
4044 if ( python_pltr ) // if not something is terribly wrong
4045 { // hold a reference to the data object
4046 Py_XINCREF( pdata );
4047 // grab the Global Interpreter Lock to be sure threads don't mess us up
4049 // build the argument list
4050#ifdef PL_DOUBLE
4051 arglist = Py_BuildValue( "(ddO)", x, y, pdata );
4052#else
4053 arglist = Py_BuildValue( "(ffO)", x, y, pdata );
4054#endif
4055 if ( arglist == NULL )
4056 {
4057 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
4058 *tx = *ty = 0;
4059 return;
4060 }
4061 // call the python function
4062 result = PyObject_CallObject( python_pltr, arglist );
4063 // release the argument list
4064 Py_CLEAR( arglist );
4065 // check and unpack the result
4066 if ( result == NULL )
4067 {
4068 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
4069 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
4070 *tx = *ty = 0;
4071 }
4072 else
4073 {
4074 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
4075 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
4076 {
4077 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
4078 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
4079 *tx = *ty = 0;
4080 }
4081 else
4082 {
4083 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
4084 *tx = t[0];
4085 *ty = t[1];
4086 Py_CLEAR( tmp );
4087 }
4088 }
4089 // release the result
4090 Py_CLEAR( result );
4091 // release the global interpreter lock
4093 }
4094 }
4095
4097 {
4098 PyObject *pdata, *arglist, *result;
4099 PLFLT fresult = 0.0;
4100
4101 // the data argument is acutally a pointer to a python object
4102 pdata = (PyObject *) data;
4103 if ( python_f2eval ) // if not something is terribly wrong
4104 { // hold a reference to the data object
4105 Py_XINCREF( pdata );
4106 // grab the Global Interpreter Lock to be sure threads don't mess us up
4108 // build the argument list
4109 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
4110 // call the python function
4111 result = PyObject_CallObject( python_f2eval, arglist );
4112 // release the argument list
4113 Py_CLEAR( arglist );
4114 // check and unpack the result
4115 if ( !PyFloat_Check( result ) )
4116 {
4117 fprintf( stderr, "f2eval callback must return a float\n" );
4118 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
4119 }
4120 else
4121 {
4122 // should I test the type here?
4123 fresult = (PLFLT) PyFloat_AsDouble( result );
4124 }
4125 // release the result
4126 Py_CLEAR( result );
4127 // release the global interpreter lock
4129 }
4130 return fresult;
4131 }
4132
4133 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
4134 {
4135 PyObject *pdata, *arglist, *result, *unicode_string;
4136 char *pystring;
4137
4138 // the data argument is acutally a pointer to a python object
4139 if ( data )
4140 pdata = (PyObject *) data;
4141 else
4142 pdata = Py_None;
4143 if ( python_label ) // if not something is terribly wrong
4144 { // hold a reference to the data object
4145 Py_XINCREF( pdata );
4146 // grab the Global Interpreter Lock to be sure threads don't mess us up
4148 // build the argument list
4149#ifdef PL_DOUBLE
4150 arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
4151#else
4152 arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
4153#endif
4154 // call the python function
4155 result = PyObject_CallObject( python_label, arglist );
4156 // release the argument list
4157 //Py_CLEAR(arglist);
4158 // check and unpack the result
4159 if ( result == NULL )
4160 {
4161 fprintf( stderr, "label callback failed with 3 arguments\n" );
4162 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
4163 }
4164 else if ( PyString_Check( result ) )
4165 {
4166 // should I test the type here?
4167 pystring = PyString_AsString( result );
4168 strncpy( string, pystring, len );
4169 }
4170 else if ( PyUnicode_Check( result ) )
4171 {
4172 // unicode_string is never freed? memory leak here?
4173 unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
4174 pystring = PyBytes_AS_STRING( unicode_string );
4175 // len may be different then the byte string length w/ unicode?
4176 strncpy( string, pystring, len );
4177 }
4178 else
4179 {
4180 fprintf( stderr, "label callback must return a string\n" );
4181 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
4182 }
4183 // release the result
4184 Py_CLEAR( result );
4185 // release the global interpreter lock
4187 }
4188 }
4189
4190 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
4191 {
4192 PyObject *px, *py, *pdata, *arglist, *result;
4193 npy_intp n;
4194 n = 1;
4195
4196 // the data argument is acutally a pointer to a python object
4197 pdata = (PyObject *) data;
4198 if ( data == NULL )
4199 {
4200 pdata = Py_None;
4201 }
4202 if ( python_ct ) // if not something is terribly wrong
4203 { // hold a reference to the data object
4204 Py_XINCREF( pdata );
4205 // grab the Global Interpreter Lock to be sure threads don't mess us up
4207 // build the argument list
4208 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
4209 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
4210 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
4211 // call the python function
4212 result = PyObject_CallObject( python_ct, arglist );
4213 // release the argument list
4214 Py_CLEAR( arglist );
4215 Py_CLEAR( px );
4216 Py_CLEAR( py );
4217 Py_CLEAR( pdata );
4218 // check and unpack the result
4219 if ( result == NULL )
4220 {
4221 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
4222 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
4223 }
4224 // release the result
4225 Py_CLEAR( result );
4226 // release the global interpreter lock
4228 }
4229 }
4230
4232 {
4233 PyObject *px, *py, *arglist, *result;
4234 // PyArrayObject *tmpx, *tmpy;
4235// PLFLT *xx, *yy;
4236// PLINT i;
4237 npy_intp nn;
4238 nn = n;
4239
4240 if ( python_mapform ) // if not something is terribly wrong
4241 { // grab the Global Interpreter Lock to be sure threads don't mess us up
4243 // build the argument list
4244#ifdef PL_HAVE_PTHREAD
4245 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
4246 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
4247#else
4248 px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
4249 py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
4250#endif
4251 arglist = Py_BuildValue( "(iOO)", n, px, py );
4252 // call the python function
4253 result = PyObject_CallObject( python_mapform, arglist );
4254 // release the argument list
4255 Py_CLEAR( arglist );
4256 Py_CLEAR( px );
4257 Py_CLEAR( py );
4258 // check and unpack the result
4259 if ( result == NULL )
4260 {
4261 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
4262 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
4263 }
4264 // release the result
4265 Py_CLEAR( result );
4266 // release the global interpreter lock
4268 }
4269 }
4270
4271// marshal the pltr function pointer argument
4272 pltr_func marshal_pltr( PyObject* input )
4273 {
4274 pltr_func result = do_pltr_callback;
4275 PyObject * rep = PyObject_Repr( input );
4276 if ( rep )
4277 {
4278 // Memory leaks here? str and uni_str are not freed?
4279 char* str;
4280 if ( PyUnicode_Check( rep ) )
4281 {
4282 PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
4283 str = PyBytes_AS_STRING( uni_str );
4284 }
4285 else
4286 {
4287 str = PyString_AsString( rep );
4288 }
4289 if ( strstr( str, "function pltr0" ) != 0 )
4290 {
4291 result = pltr0;
4292 pltr_type = CB_0;
4293 python_pltr = NULL;
4294 }
4295 else if ( strstr( str, "function pltr1" ) != 0 )
4296 {
4297 result = pltr1;
4298 pltr_type = CB_1;
4299 python_pltr = NULL;
4300 }
4301 else if ( strstr( str, "function pltr2" ) != 0 )
4302 {
4303 result = pltr2;
4304 pltr_type = CB_2;
4305 python_pltr = NULL;
4306 }
4307 else
4308 {
4309 python_pltr = input;
4311 Py_XINCREF( input );
4312 }
4313 Py_CLEAR( rep );
4314 }
4315 else
4316 {
4317 python_pltr = input;
4319 Py_XINCREF( input );
4320 }
4321 return result;
4322 }
4323
4324 void cleanup_pltr( void )
4325 {
4326 Py_CLEAR( python_pltr );
4327 python_pltr = 0;
4328 }
4329
4330// marshal the ct function pointer argument
4331 ct_func marshal_ct( PyObject* input )
4332 {
4333 ct_func result = do_ct_callback;
4334 python_ct = input;
4335 Py_XINCREF( input );
4336 return result;
4337 }
4338
4339 void cleanup_ct( void )
4340 {
4341 Py_CLEAR( python_ct );
4342 python_ct = 0;
4343 }
4344
4345// marshal the mapform function pointer argument
4347 {
4349 python_mapform = input;
4350 Py_XINCREF( input );
4351 return result;
4352 }
4353
4354 void cleanup_mapform( void )
4355 {
4356 Py_CLEAR( python_mapform );
4357 python_mapform = 0;
4358 }
4359
4360 PLPointer marshal_PLPointer( PyObject* input, int isimg )
4361 {
4362 PLPointer result = NULL;
4363 switch ( pltr_type )
4364 {
4365 case CB_0:
4366 break;
4367 case CB_1:
4368 if ( input != Py_None )
4369 result = marshal_PLcGrid1( input, isimg );
4370 break;
4371 case CB_2:
4372 if ( input != Py_None )
4373 result = marshal_PLcGrid2( input, isimg );
4374 break;
4375 case CB_Python:
4376 Py_XINCREF( input );
4377 result = (PLPointer *) input;
4378 break;
4379 default:
4380 fprintf( stderr, "pltr_type is invalid\n" );
4381 }
4382 return result;
4383 }
4384
4386 {
4387 switch ( pltr_type )
4388 {
4389 case CB_0:
4390 break;
4391 case CB_1:
4393 break;
4394 case CB_2:
4396 break;
4397 case CB_Python:
4398 Py_CLEAR( python_pltr );
4399 break;
4400 default:
4401 fprintf( stderr, "pltr_type is invalid\n" );
4402 }
4403 python_pltr = 0;
4404 pltr_type = CB_0;
4405 }
4406
4407
4408
4409SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args) {
4410 PyObject *resultobj = 0;
4411 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4412 int arg2 ;
4413 void *argp1 = 0 ;
4414 int res1 = 0 ;
4415 int val2 ;
4416 int ecode2 = 0 ;
4417 PyObject *swig_obj[2] ;
4418
4419 (void)self;
4420 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_type_set", 2, 2, swig_obj)) SWIG_fail;
4421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4422 if (!SWIG_IsOK(res1)) {
4423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4424 }
4425 arg1 = (PLGraphicsIn *)(argp1);
4426 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4427 if (!SWIG_IsOK(ecode2)) {
4428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4429 }
4430 arg2 = (int)(val2);
4431 if (arg1) (arg1)->type = arg2;
4432 resultobj = SWIG_Py_Void();
4433 return resultobj;
4434fail:
4435 return NULL;
4436}
4437
4438
4439SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args) {
4440 PyObject *resultobj = 0;
4441 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4442 void *argp1 = 0 ;
4443 int res1 = 0 ;
4444 PyObject *swig_obj[1] ;
4445 int result;
4446
4447 (void)self;
4448 if (!args) SWIG_fail;
4449 swig_obj[0] = args;
4450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4451 if (!SWIG_IsOK(res1)) {
4452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4453 }
4454 arg1 = (PLGraphicsIn *)(argp1);
4455 result = (int) ((arg1)->type);
4456 resultobj = SWIG_From_int((int)(result));
4457 return resultobj;
4458fail:
4459 return NULL;
4460}
4461
4462
4463SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args) {
4464 PyObject *resultobj = 0;
4465 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4466 unsigned int arg2 ;
4467 void *argp1 = 0 ;
4468 int res1 = 0 ;
4469 unsigned int val2 ;
4470 int ecode2 = 0 ;
4471 PyObject *swig_obj[2] ;
4472
4473 (void)self;
4474 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_state_set", 2, 2, swig_obj)) SWIG_fail;
4475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4476 if (!SWIG_IsOK(res1)) {
4477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4478 }
4479 arg1 = (PLGraphicsIn *)(argp1);
4480 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4481 if (!SWIG_IsOK(ecode2)) {
4482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4483 }
4484 arg2 = (unsigned int)(val2);
4485 if (arg1) (arg1)->state = arg2;
4486 resultobj = SWIG_Py_Void();
4487 return resultobj;
4488fail:
4489 return NULL;
4490}
4491
4492
4493SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args) {
4494 PyObject *resultobj = 0;
4495 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4496 void *argp1 = 0 ;
4497 int res1 = 0 ;
4498 PyObject *swig_obj[1] ;
4499 unsigned int result;
4500
4501 (void)self;
4502 if (!args) SWIG_fail;
4503 swig_obj[0] = args;
4504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4505 if (!SWIG_IsOK(res1)) {
4506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4507 }
4508 arg1 = (PLGraphicsIn *)(argp1);
4509 result = (unsigned int) ((arg1)->state);
4510 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4511 return resultobj;
4512fail:
4513 return NULL;
4514}
4515
4516
4517SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args) {
4518 PyObject *resultobj = 0;
4519 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4520 unsigned int arg2 ;
4521 void *argp1 = 0 ;
4522 int res1 = 0 ;
4523 unsigned int val2 ;
4524 int ecode2 = 0 ;
4525 PyObject *swig_obj[2] ;
4526
4527 (void)self;
4528 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_keysym_set", 2, 2, swig_obj)) SWIG_fail;
4529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4530 if (!SWIG_IsOK(res1)) {
4531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4532 }
4533 arg1 = (PLGraphicsIn *)(argp1);
4534 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4535 if (!SWIG_IsOK(ecode2)) {
4536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4537 }
4538 arg2 = (unsigned int)(val2);
4539 if (arg1) (arg1)->keysym = arg2;
4540 resultobj = SWIG_Py_Void();
4541 return resultobj;
4542fail:
4543 return NULL;
4544}
4545
4546
4547SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args) {
4548 PyObject *resultobj = 0;
4549 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4550 void *argp1 = 0 ;
4551 int res1 = 0 ;
4552 PyObject *swig_obj[1] ;
4553 unsigned int result;
4554
4555 (void)self;
4556 if (!args) SWIG_fail;
4557 swig_obj[0] = args;
4558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4559 if (!SWIG_IsOK(res1)) {
4560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4561 }
4562 arg1 = (PLGraphicsIn *)(argp1);
4563 result = (unsigned int) ((arg1)->keysym);
4564 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4565 return resultobj;
4566fail:
4567 return NULL;
4568}
4569
4570
4571SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args) {
4572 PyObject *resultobj = 0;
4573 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4574 unsigned int arg2 ;
4575 void *argp1 = 0 ;
4576 int res1 = 0 ;
4577 unsigned int val2 ;
4578 int ecode2 = 0 ;
4579 PyObject *swig_obj[2] ;
4580
4581 (void)self;
4582 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_button_set", 2, 2, swig_obj)) SWIG_fail;
4583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4584 if (!SWIG_IsOK(res1)) {
4585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4586 }
4587 arg1 = (PLGraphicsIn *)(argp1);
4588 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4589 if (!SWIG_IsOK(ecode2)) {
4590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4591 }
4592 arg2 = (unsigned int)(val2);
4593 if (arg1) (arg1)->button = arg2;
4594 resultobj = SWIG_Py_Void();
4595 return resultobj;
4596fail:
4597 return NULL;
4598}
4599
4600
4601SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args) {
4602 PyObject *resultobj = 0;
4603 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4604 void *argp1 = 0 ;
4605 int res1 = 0 ;
4606 PyObject *swig_obj[1] ;
4607 unsigned int result;
4608
4609 (void)self;
4610 if (!args) SWIG_fail;
4611 swig_obj[0] = args;
4612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4613 if (!SWIG_IsOK(res1)) {
4614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4615 }
4616 arg1 = (PLGraphicsIn *)(argp1);
4617 result = (unsigned int) ((arg1)->button);
4618 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4619 return resultobj;
4620fail:
4621 return NULL;
4622}
4623
4624
4625SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args) {
4626 PyObject *resultobj = 0;
4627 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4628 PLINT arg2 ;
4629 void *argp1 = 0 ;
4630 int res1 = 0 ;
4631 int val2 ;
4632 int ecode2 = 0 ;
4633 PyObject *swig_obj[2] ;
4634
4635 (void)self;
4636 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_subwindow_set", 2, 2, swig_obj)) SWIG_fail;
4637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4638 if (!SWIG_IsOK(res1)) {
4639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4640 }
4641 arg1 = (PLGraphicsIn *)(argp1);
4642 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4643 if (!SWIG_IsOK(ecode2)) {
4644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4645 }
4646 arg2 = (PLINT)(val2);
4647 if (arg1) (arg1)->subwindow = arg2;
4648 resultobj = SWIG_Py_Void();
4649 return resultobj;
4650fail:
4651 return NULL;
4652}
4653
4654
4655SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args) {
4656 PyObject *resultobj = 0;
4657 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4658 void *argp1 = 0 ;
4659 int res1 = 0 ;
4660 PyObject *swig_obj[1] ;
4661 PLINT result;
4662
4663 (void)self;
4664 if (!args) SWIG_fail;
4665 swig_obj[0] = args;
4666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4667 if (!SWIG_IsOK(res1)) {
4668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4669 }
4670 arg1 = (PLGraphicsIn *)(argp1);
4671 result = (PLINT) ((arg1)->subwindow);
4672 resultobj = SWIG_From_int((int)(result));
4673 return resultobj;
4674fail:
4675 return NULL;
4676}
4677
4678
4679SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args) {
4680 PyObject *resultobj = 0;
4681 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4682 char *arg2 = (char *) (char *)0 ;
4683 void *argp1 = 0 ;
4684 int res1 = 0 ;
4685 char temp2[16] ;
4686 int res2 ;
4687 PyObject *swig_obj[2] ;
4688
4689 (void)self;
4690 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_string_set", 2, 2, swig_obj)) SWIG_fail;
4691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4692 if (!SWIG_IsOK(res1)) {
4693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4694 }
4695 arg1 = (PLGraphicsIn *)(argp1);
4696 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 16);
4697 if (!SWIG_IsOK(res2)) {
4698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4699 }
4700 arg2 = (char *)(temp2);
4701 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4702 else memset(arg1->string,0,16*sizeof(char));
4703 resultobj = SWIG_Py_Void();
4704 return resultobj;
4705fail:
4706 return NULL;
4707}
4708
4709
4710SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args) {
4711 PyObject *resultobj = 0;
4712 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4713 void *argp1 = 0 ;
4714 int res1 = 0 ;
4715 PyObject *swig_obj[1] ;
4716 char *result = 0 ;
4717
4718 (void)self;
4719 if (!args) SWIG_fail;
4720 swig_obj[0] = args;
4721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4722 if (!SWIG_IsOK(res1)) {
4723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4724 }
4725 arg1 = (PLGraphicsIn *)(argp1);
4726 result = (char *)(char *) ((arg1)->string);
4727 {
4728 size_t size = SWIG_strnlen(result, 16);
4729
4730
4731
4732 resultobj = SWIG_FromCharPtrAndSize(result, size);
4733 }
4734 return resultobj;
4735fail:
4736 return NULL;
4737}
4738
4739
4740SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args) {
4741 PyObject *resultobj = 0;
4742 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4743 int arg2 ;
4744 void *argp1 = 0 ;
4745 int res1 = 0 ;
4746 int val2 ;
4747 int ecode2 = 0 ;
4748 PyObject *swig_obj[2] ;
4749
4750 (void)self;
4751 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pX_set", 2, 2, swig_obj)) SWIG_fail;
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_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4755 }
4756 arg1 = (PLGraphicsIn *)(argp1);
4757 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4758 if (!SWIG_IsOK(ecode2)) {
4759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4760 }
4761 arg2 = (int)(val2);
4762 if (arg1) (arg1)->pX = arg2;
4763 resultobj = SWIG_Py_Void();
4764 return resultobj;
4765fail:
4766 return NULL;
4767}
4768
4769
4770SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args) {
4771 PyObject *resultobj = 0;
4772 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4773 void *argp1 = 0 ;
4774 int res1 = 0 ;
4775 PyObject *swig_obj[1] ;
4776 int result;
4777
4778 (void)self;
4779 if (!args) SWIG_fail;
4780 swig_obj[0] = args;
4781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4782 if (!SWIG_IsOK(res1)) {
4783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4784 }
4785 arg1 = (PLGraphicsIn *)(argp1);
4786 result = (int) ((arg1)->pX);
4787 resultobj = SWIG_From_int((int)(result));
4788 return resultobj;
4789fail:
4790 return NULL;
4791}
4792
4793
4794SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args) {
4795 PyObject *resultobj = 0;
4796 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4797 int arg2 ;
4798 void *argp1 = 0 ;
4799 int res1 = 0 ;
4800 int val2 ;
4801 int ecode2 = 0 ;
4802 PyObject *swig_obj[2] ;
4803
4804 (void)self;
4805 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pY_set", 2, 2, swig_obj)) SWIG_fail;
4806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4807 if (!SWIG_IsOK(res1)) {
4808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4809 }
4810 arg1 = (PLGraphicsIn *)(argp1);
4811 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4812 if (!SWIG_IsOK(ecode2)) {
4813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4814 }
4815 arg2 = (int)(val2);
4816 if (arg1) (arg1)->pY = arg2;
4817 resultobj = SWIG_Py_Void();
4818 return resultobj;
4819fail:
4820 return NULL;
4821}
4822
4823
4824SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args) {
4825 PyObject *resultobj = 0;
4826 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4827 void *argp1 = 0 ;
4828 int res1 = 0 ;
4829 PyObject *swig_obj[1] ;
4830 int result;
4831
4832 (void)self;
4833 if (!args) SWIG_fail;
4834 swig_obj[0] = args;
4835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4836 if (!SWIG_IsOK(res1)) {
4837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4838 }
4839 arg1 = (PLGraphicsIn *)(argp1);
4840 result = (int) ((arg1)->pY);
4841 resultobj = SWIG_From_int((int)(result));
4842 return resultobj;
4843fail:
4844 return NULL;
4845}
4846
4847
4848SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args) {
4849 PyObject *resultobj = 0;
4850 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4851 PLFLT arg2 ;
4852 void *argp1 = 0 ;
4853 int res1 = 0 ;
4854 double val2 ;
4855 int ecode2 = 0 ;
4856 PyObject *swig_obj[2] ;
4857
4858 (void)self;
4859 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dX_set", 2, 2, swig_obj)) SWIG_fail;
4860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4861 if (!SWIG_IsOK(res1)) {
4862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4863 }
4864 arg1 = (PLGraphicsIn *)(argp1);
4865 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4866 if (!SWIG_IsOK(ecode2)) {
4867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4868 }
4869 arg2 = (PLFLT)(val2);
4870 if (arg1) (arg1)->dX = arg2;
4871 resultobj = SWIG_Py_Void();
4872 return resultobj;
4873fail:
4874 return NULL;
4875}
4876
4877
4878SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args) {
4879 PyObject *resultobj = 0;
4880 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4881 void *argp1 = 0 ;
4882 int res1 = 0 ;
4883 PyObject *swig_obj[1] ;
4884 PLFLT result;
4885
4886 (void)self;
4887 if (!args) SWIG_fail;
4888 swig_obj[0] = args;
4889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4890 if (!SWIG_IsOK(res1)) {
4891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4892 }
4893 arg1 = (PLGraphicsIn *)(argp1);
4894 result = (PLFLT) ((arg1)->dX);
4895 resultobj = SWIG_From_double((double)(result));
4896 return resultobj;
4897fail:
4898 return NULL;
4899}
4900
4901
4902SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args) {
4903 PyObject *resultobj = 0;
4904 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4905 PLFLT arg2 ;
4906 void *argp1 = 0 ;
4907 int res1 = 0 ;
4908 double val2 ;
4909 int ecode2 = 0 ;
4910 PyObject *swig_obj[2] ;
4911
4912 (void)self;
4913 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dY_set", 2, 2, swig_obj)) SWIG_fail;
4914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4915 if (!SWIG_IsOK(res1)) {
4916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4917 }
4918 arg1 = (PLGraphicsIn *)(argp1);
4919 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4920 if (!SWIG_IsOK(ecode2)) {
4921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4922 }
4923 arg2 = (PLFLT)(val2);
4924 if (arg1) (arg1)->dY = arg2;
4925 resultobj = SWIG_Py_Void();
4926 return resultobj;
4927fail:
4928 return NULL;
4929}
4930
4931
4932SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args) {
4933 PyObject *resultobj = 0;
4934 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4935 void *argp1 = 0 ;
4936 int res1 = 0 ;
4937 PyObject *swig_obj[1] ;
4938 PLFLT result;
4939
4940 (void)self;
4941 if (!args) SWIG_fail;
4942 swig_obj[0] = args;
4943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4944 if (!SWIG_IsOK(res1)) {
4945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4946 }
4947 arg1 = (PLGraphicsIn *)(argp1);
4948 result = (PLFLT) ((arg1)->dY);
4949 resultobj = SWIG_From_double((double)(result));
4950 return resultobj;
4951fail:
4952 return NULL;
4953}
4954
4955
4956SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args) {
4957 PyObject *resultobj = 0;
4958 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4959 PLFLT arg2 ;
4960 void *argp1 = 0 ;
4961 int res1 = 0 ;
4962 double val2 ;
4963 int ecode2 = 0 ;
4964 PyObject *swig_obj[2] ;
4965
4966 (void)self;
4967 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wX_set", 2, 2, swig_obj)) SWIG_fail;
4968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4969 if (!SWIG_IsOK(res1)) {
4970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4971 }
4972 arg1 = (PLGraphicsIn *)(argp1);
4973 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4974 if (!SWIG_IsOK(ecode2)) {
4975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4976 }
4977 arg2 = (PLFLT)(val2);
4978 if (arg1) (arg1)->wX = arg2;
4979 resultobj = SWIG_Py_Void();
4980 return resultobj;
4981fail:
4982 return NULL;
4983}
4984
4985
4986SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args) {
4987 PyObject *resultobj = 0;
4988 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4989 void *argp1 = 0 ;
4990 int res1 = 0 ;
4991 PyObject *swig_obj[1] ;
4992 PLFLT result;
4993
4994 (void)self;
4995 if (!args) SWIG_fail;
4996 swig_obj[0] = args;
4997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4998 if (!SWIG_IsOK(res1)) {
4999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5000 }
5001 arg1 = (PLGraphicsIn *)(argp1);
5002 result = (PLFLT) ((arg1)->wX);
5003 resultobj = SWIG_From_double((double)(result));
5004 return resultobj;
5005fail:
5006 return NULL;
5007}
5008
5009
5010SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args) {
5011 PyObject *resultobj = 0;
5012 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5013 PLFLT arg2 ;
5014 void *argp1 = 0 ;
5015 int res1 = 0 ;
5016 double val2 ;
5017 int ecode2 = 0 ;
5018 PyObject *swig_obj[2] ;
5019
5020 (void)self;
5021 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wY_set", 2, 2, swig_obj)) SWIG_fail;
5022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5023 if (!SWIG_IsOK(res1)) {
5024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5025 }
5026 arg1 = (PLGraphicsIn *)(argp1);
5027 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5028 if (!SWIG_IsOK(ecode2)) {
5029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
5030 }
5031 arg2 = (PLFLT)(val2);
5032 if (arg1) (arg1)->wY = arg2;
5033 resultobj = SWIG_Py_Void();
5034 return resultobj;
5035fail:
5036 return NULL;
5037}
5038
5039
5040SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args) {
5041 PyObject *resultobj = 0;
5042 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5043 void *argp1 = 0 ;
5044 int res1 = 0 ;
5045 PyObject *swig_obj[1] ;
5046 PLFLT result;
5047
5048 (void)self;
5049 if (!args) SWIG_fail;
5050 swig_obj[0] = args;
5051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5052 if (!SWIG_IsOK(res1)) {
5053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5054 }
5055 arg1 = (PLGraphicsIn *)(argp1);
5056 result = (PLFLT) ((arg1)->wY);
5057 resultobj = SWIG_From_double((double)(result));
5058 return resultobj;
5059fail:
5060 return NULL;
5061}
5062
5063
5064SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *self, PyObject *args) {
5065 PyObject *resultobj = 0;
5066 PLGraphicsIn *result = 0 ;
5067
5068 (void)self;
5069 if (!SWIG_Python_UnpackTuple(args, "new_PLGraphicsIn", 0, 0, 0)) SWIG_fail;
5070 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
5072 return resultobj;
5073fail:
5074 return NULL;
5075}
5076
5077
5078SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args) {
5079 PyObject *resultobj = 0;
5080 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5081 void *argp1 = 0 ;
5082 int res1 = 0 ;
5083 PyObject *swig_obj[1] ;
5084
5085 (void)self;
5086 if (!args) SWIG_fail;
5087 swig_obj[0] = args;
5088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
5089 if (!SWIG_IsOK(res1)) {
5090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5091 }
5092 arg1 = (PLGraphicsIn *)(argp1);
5093 free((char *) arg1);
5094 resultobj = SWIG_Py_Void();
5095 return resultobj;
5096fail:
5097 return NULL;
5098}
5099
5100
5101SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5102 PyObject *obj;
5103 if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
5105 return SWIG_Py_Void();
5106}
5107
5108SWIGINTERN PyObject *PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5109 return SWIG_Python_InitShadowInstance(args);
5110}
5111
5112SWIGINTERN PyObject *_wrap_plsxwin(PyObject *self, PyObject *args) {
5113 PyObject *resultobj = 0;
5114 PLINT arg1 ;
5115 int val1 ;
5116 int ecode1 = 0 ;
5117 PyObject *swig_obj[1] ;
5118
5119 (void)self;
5120 if (!args) SWIG_fail;
5121 swig_obj[0] = args;
5122 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5123 if (!SWIG_IsOK(ecode1)) {
5124 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
5125 }
5126 arg1 = (PLINT)(val1);
5127 plsxwin(arg1);
5128 resultobj = SWIG_Py_Void();
5129 return resultobj;
5130fail:
5131 return NULL;
5132}
5133
5134
5135SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *self, PyObject *args) {
5136 PyObject *resultobj = 0;
5137 PLINT arg1 ;
5138 PLINT arg2 ;
5139 int val1 ;
5140 int ecode1 = 0 ;
5141 int val2 ;
5142 int ecode2 = 0 ;
5143 PyObject *swig_obj[2] ;
5144
5145 (void)self;
5146 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelformat", 2, 2, swig_obj)) SWIG_fail;
5147 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5148 if (!SWIG_IsOK(ecode1)) {
5149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
5150 }
5151 arg1 = (PLINT)(val1);
5152 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5153 if (!SWIG_IsOK(ecode2)) {
5154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
5155 }
5156 arg2 = (PLINT)(val2);
5157 pl_setcontlabelformat(arg1,arg2);
5158 resultobj = SWIG_Py_Void();
5159 return resultobj;
5160fail:
5161 return NULL;
5162}
5163
5164
5165SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *self, PyObject *args) {
5166 PyObject *resultobj = 0;
5167 PLFLT arg1 ;
5168 PLFLT arg2 ;
5169 PLFLT arg3 ;
5170 PLINT arg4 ;
5171 double val1 ;
5172 int ecode1 = 0 ;
5173 double val2 ;
5174 int ecode2 = 0 ;
5175 double val3 ;
5176 int ecode3 = 0 ;
5177 int val4 ;
5178 int ecode4 = 0 ;
5179 PyObject *swig_obj[4] ;
5180
5181 (void)self;
5182 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelparam", 4, 4, swig_obj)) SWIG_fail;
5183 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5184 if (!SWIG_IsOK(ecode1)) {
5185 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
5186 }
5187 arg1 = (PLFLT)(val1);
5188 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5189 if (!SWIG_IsOK(ecode2)) {
5190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
5191 }
5192 arg2 = (PLFLT)(val2);
5193 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5194 if (!SWIG_IsOK(ecode3)) {
5195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
5196 }
5197 arg3 = (PLFLT)(val3);
5198 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5199 if (!SWIG_IsOK(ecode4)) {
5200 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
5201 }
5202 arg4 = (PLINT)(val4);
5203 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
5204 resultobj = SWIG_Py_Void();
5205 return resultobj;
5206fail:
5207 return NULL;
5208}
5209
5210
5211SWIGINTERN PyObject *_wrap_pladv(PyObject *self, PyObject *args) {
5212 PyObject *resultobj = 0;
5213 PLINT arg1 ;
5214 int val1 ;
5215 int ecode1 = 0 ;
5216 PyObject *swig_obj[1] ;
5217
5218 (void)self;
5219 if (!args) SWIG_fail;
5220 swig_obj[0] = args;
5221 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5222 if (!SWIG_IsOK(ecode1)) {
5223 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
5224 }
5225 arg1 = (PLINT)(val1);
5226 pladv(arg1);
5227 resultobj = SWIG_Py_Void();
5228 return resultobj;
5229fail:
5230 return NULL;
5231}
5232
5233
5234SWIGINTERN PyObject *_wrap_plarc(PyObject *self, PyObject *args) {
5235 PyObject *resultobj = 0;
5236 PLFLT arg1 ;
5237 PLFLT arg2 ;
5238 PLFLT arg3 ;
5239 PLFLT arg4 ;
5240 PLFLT arg5 ;
5241 PLFLT arg6 ;
5242 PLFLT arg7 ;
5243 PLBOOL arg8 ;
5244 double val1 ;
5245 int ecode1 = 0 ;
5246 double val2 ;
5247 int ecode2 = 0 ;
5248 double val3 ;
5249 int ecode3 = 0 ;
5250 double val4 ;
5251 int ecode4 = 0 ;
5252 double val5 ;
5253 int ecode5 = 0 ;
5254 double val6 ;
5255 int ecode6 = 0 ;
5256 double val7 ;
5257 int ecode7 = 0 ;
5258 int val8 ;
5259 int ecode8 = 0 ;
5260 PyObject *swig_obj[8] ;
5261
5262 (void)self;
5263 if (!SWIG_Python_UnpackTuple(args, "plarc", 8, 8, swig_obj)) SWIG_fail;
5264 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5265 if (!SWIG_IsOK(ecode1)) {
5266 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
5267 }
5268 arg1 = (PLFLT)(val1);
5269 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5270 if (!SWIG_IsOK(ecode2)) {
5271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
5272 }
5273 arg2 = (PLFLT)(val2);
5274 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5275 if (!SWIG_IsOK(ecode3)) {
5276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
5277 }
5278 arg3 = (PLFLT)(val3);
5279 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5280 if (!SWIG_IsOK(ecode4)) {
5281 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
5282 }
5283 arg4 = (PLFLT)(val4);
5284 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5285 if (!SWIG_IsOK(ecode5)) {
5286 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
5287 }
5288 arg5 = (PLFLT)(val5);
5289 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5290 if (!SWIG_IsOK(ecode6)) {
5291 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
5292 }
5293 arg6 = (PLFLT)(val6);
5294 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5295 if (!SWIG_IsOK(ecode7)) {
5296 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
5297 }
5298 arg7 = (PLFLT)(val7);
5299 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5300 if (!SWIG_IsOK(ecode8)) {
5301 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
5302 }
5303 arg8 = (PLBOOL)(val8);
5304 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5305 resultobj = SWIG_Py_Void();
5306 return resultobj;
5307fail:
5308 return NULL;
5309}
5310
5311
5312SWIGINTERN PyObject *_wrap_plaxes(PyObject *self, PyObject *args) {
5313 PyObject *resultobj = 0;
5314 PLFLT arg1 ;
5315 PLFLT arg2 ;
5316 char *arg3 = (char *) 0 ;
5317 PLFLT arg4 ;
5318 PLINT arg5 ;
5319 char *arg6 = (char *) 0 ;
5320 PLFLT arg7 ;
5321 PLINT arg8 ;
5322 double val1 ;
5323 int ecode1 = 0 ;
5324 double val2 ;
5325 int ecode2 = 0 ;
5326 int res3 ;
5327 char *buf3 = 0 ;
5328 int alloc3 = 0 ;
5329 double val4 ;
5330 int ecode4 = 0 ;
5331 int val5 ;
5332 int ecode5 = 0 ;
5333 int res6 ;
5334 char *buf6 = 0 ;
5335 int alloc6 = 0 ;
5336 double val7 ;
5337 int ecode7 = 0 ;
5338 int val8 ;
5339 int ecode8 = 0 ;
5340 PyObject *swig_obj[8] ;
5341
5342 (void)self;
5343 if (!SWIG_Python_UnpackTuple(args, "plaxes", 8, 8, swig_obj)) SWIG_fail;
5344 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5345 if (!SWIG_IsOK(ecode1)) {
5346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5347 }
5348 arg1 = (PLFLT)(val1);
5349 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5350 if (!SWIG_IsOK(ecode2)) {
5351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5352 }
5353 arg2 = (PLFLT)(val2);
5354 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
5355 if (!SWIG_IsOK(res3)) {
5356 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5357 }
5358 arg3 = (char *)(buf3);
5359 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5360 if (!SWIG_IsOK(ecode4)) {
5361 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5362 }
5363 arg4 = (PLFLT)(val4);
5364 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5365 if (!SWIG_IsOK(ecode5)) {
5366 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5367 }
5368 arg5 = (PLINT)(val5);
5369 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5370 if (!SWIG_IsOK(res6)) {
5371 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5372 }
5373 arg6 = (char *)(buf6);
5374 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5375 if (!SWIG_IsOK(ecode7)) {
5376 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5377 }
5378 arg7 = (PLFLT)(val7);
5379 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5380 if (!SWIG_IsOK(ecode8)) {
5381 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5382 }
5383 arg8 = (PLINT)(val8);
5384 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5385 resultobj = SWIG_Py_Void();
5386 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5387 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5388 return resultobj;
5389fail:
5390 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5391 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5392 return NULL;
5393}
5394
5395
5396SWIGINTERN PyObject *_wrap_plbin(PyObject *self, PyObject *args) {
5397 PyObject *resultobj = 0;
5398 PLINT arg1 ;
5399 PLFLT *arg2 = (PLFLT *) 0 ;
5400 PLFLT *arg3 = (PLFLT *) 0 ;
5401 PLINT arg4 ;
5402 PyArrayObject *tmp1 = NULL ;
5403 PyArrayObject *tmp3 = NULL ;
5404 int val4 ;
5405 int ecode4 = 0 ;
5406 PyObject *swig_obj[3] ;
5407
5408 (void)self;
5409 if (!SWIG_Python_UnpackTuple(args, "plbin", 3, 3, swig_obj)) SWIG_fail;
5410 {
5411 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5412 if ( tmp1 == NULL )
5413 return NULL;
5414 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5415 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5416 }
5417 {
5418 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5419 if ( tmp3 == NULL )
5420 return NULL;
5421 if ( PyArray_DIMS( tmp3 )[0] != Alen )
5422 {
5423 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5424 return NULL;
5425 }
5426 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5427 }
5428 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
5429 if (!SWIG_IsOK(ecode4)) {
5430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5431 }
5432 arg4 = (PLINT)(val4);
5433 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5434 resultobj = SWIG_Py_Void();
5435 {
5436 Py_CLEAR( tmp1 );
5437 }
5438 {
5439 Py_CLEAR( tmp3 );
5440 }
5441 return resultobj;
5442fail:
5443 {
5444 Py_CLEAR( tmp1 );
5445 }
5446 {
5447 Py_CLEAR( tmp3 );
5448 }
5449 return NULL;
5450}
5451
5452
5453SWIGINTERN PyObject *_wrap_plbtime(PyObject *self, PyObject *args) {
5454 PyObject *resultobj = 0;
5455 PLINT *arg1 = (PLINT *) 0 ;
5456 PLINT *arg2 = (PLINT *) 0 ;
5457 PLINT *arg3 = (PLINT *) 0 ;
5458 PLINT *arg4 = (PLINT *) 0 ;
5459 PLINT *arg5 = (PLINT *) 0 ;
5460 PLFLT *arg6 = (PLFLT *) 0 ;
5461 PLFLT arg7 ;
5462 PLINT temp1 ;
5463 int res1 = SWIG_TMPOBJ ;
5464 PLINT temp2 ;
5465 int res2 = SWIG_TMPOBJ ;
5466 PLINT temp3 ;
5467 int res3 = SWIG_TMPOBJ ;
5468 PLINT temp4 ;
5469 int res4 = SWIG_TMPOBJ ;
5470 PLINT temp5 ;
5471 int res5 = SWIG_TMPOBJ ;
5472 PLFLT temp6 ;
5473 int res6 = SWIG_TMPOBJ ;
5474 double val7 ;
5475 int ecode7 = 0 ;
5476 PyObject *swig_obj[1] ;
5477
5478 arg1 = &temp1;
5479 arg2 = &temp2;
5480 arg3 = &temp3;
5481 arg4 = &temp4;
5482 arg5 = &temp5;
5483 arg6 = &temp6;
5484 (void)self;
5485 if (!args) SWIG_fail;
5486 swig_obj[0] = args;
5487 ecode7 = SWIG_AsVal_double(swig_obj[0], &val7);
5488 if (!SWIG_IsOK(ecode7)) {
5489 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5490 }
5491 arg7 = (PLFLT)(val7);
5492 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5493 resultobj = SWIG_Py_Void();
5494 if (SWIG_IsTmpObj(res1)) {
5495 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5496 } else {
5497 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5498 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5499 }
5500 if (SWIG_IsTmpObj(res2)) {
5501 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5502 } else {
5503 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5504 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5505 }
5506 if (SWIG_IsTmpObj(res3)) {
5507 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
5508 } else {
5509 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5510 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
5511 }
5512 if (SWIG_IsTmpObj(res4)) {
5513 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5514 } else {
5515 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5517 }
5518 if (SWIG_IsTmpObj(res5)) {
5519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5520 } else {
5521 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5523 }
5524 if (SWIG_IsTmpObj(res6)) {
5525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5526 } else {
5527 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5528 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5529 }
5530 return resultobj;
5531fail:
5532 return NULL;
5533}
5534
5535
5536SWIGINTERN PyObject *_wrap_plbop(PyObject *self, PyObject *args) {
5537 PyObject *resultobj = 0;
5538
5539 (void)self;
5540 if (!SWIG_Python_UnpackTuple(args, "plbop", 0, 0, 0)) SWIG_fail;
5541 plbop();
5542 resultobj = SWIG_Py_Void();
5543 return resultobj;
5544fail:
5545 return NULL;
5546}
5547
5548
5549SWIGINTERN PyObject *_wrap_plbox(PyObject *self, PyObject *args) {
5550 PyObject *resultobj = 0;
5551 char *arg1 = (char *) 0 ;
5552 PLFLT arg2 ;
5553 PLINT arg3 ;
5554 char *arg4 = (char *) 0 ;
5555 PLFLT arg5 ;
5556 PLINT arg6 ;
5557 int res1 ;
5558 char *buf1 = 0 ;
5559 int alloc1 = 0 ;
5560 double val2 ;
5561 int ecode2 = 0 ;
5562 int val3 ;
5563 int ecode3 = 0 ;
5564 int res4 ;
5565 char *buf4 = 0 ;
5566 int alloc4 = 0 ;
5567 double val5 ;
5568 int ecode5 = 0 ;
5569 int val6 ;
5570 int ecode6 = 0 ;
5571 PyObject *swig_obj[6] ;
5572
5573 (void)self;
5574 if (!SWIG_Python_UnpackTuple(args, "plbox", 6, 6, swig_obj)) SWIG_fail;
5575 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5576 if (!SWIG_IsOK(res1)) {
5577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5578 }
5579 arg1 = (char *)(buf1);
5580 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5581 if (!SWIG_IsOK(ecode2)) {
5582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5583 }
5584 arg2 = (PLFLT)(val2);
5585 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5586 if (!SWIG_IsOK(ecode3)) {
5587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5588 }
5589 arg3 = (PLINT)(val3);
5590 res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
5591 if (!SWIG_IsOK(res4)) {
5592 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5593 }
5594 arg4 = (char *)(buf4);
5595 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5596 if (!SWIG_IsOK(ecode5)) {
5597 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5598 }
5599 arg5 = (PLFLT)(val5);
5600 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5601 if (!SWIG_IsOK(ecode6)) {
5602 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5603 }
5604 arg6 = (PLINT)(val6);
5605 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5606 resultobj = SWIG_Py_Void();
5607 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5608 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5609 return resultobj;
5610fail:
5611 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5612 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5613 return NULL;
5614}
5615
5616
5617SWIGINTERN PyObject *_wrap_plbox3(PyObject *self, PyObject *args) {
5618 PyObject *resultobj = 0;
5619 char *arg1 = (char *) 0 ;
5620 char *arg2 = (char *) 0 ;
5621 PLFLT arg3 ;
5622 PLINT arg4 ;
5623 char *arg5 = (char *) 0 ;
5624 char *arg6 = (char *) 0 ;
5625 PLFLT arg7 ;
5626 PLINT arg8 ;
5627 char *arg9 = (char *) 0 ;
5628 char *arg10 = (char *) 0 ;
5629 PLFLT arg11 ;
5630 PLINT arg12 ;
5631 int res1 ;
5632 char *buf1 = 0 ;
5633 int alloc1 = 0 ;
5634 int res2 ;
5635 char *buf2 = 0 ;
5636 int alloc2 = 0 ;
5637 double val3 ;
5638 int ecode3 = 0 ;
5639 int val4 ;
5640 int ecode4 = 0 ;
5641 int res5 ;
5642 char *buf5 = 0 ;
5643 int alloc5 = 0 ;
5644 int res6 ;
5645 char *buf6 = 0 ;
5646 int alloc6 = 0 ;
5647 double val7 ;
5648 int ecode7 = 0 ;
5649 int val8 ;
5650 int ecode8 = 0 ;
5651 int res9 ;
5652 char *buf9 = 0 ;
5653 int alloc9 = 0 ;
5654 int res10 ;
5655 char *buf10 = 0 ;
5656 int alloc10 = 0 ;
5657 double val11 ;
5658 int ecode11 = 0 ;
5659 int val12 ;
5660 int ecode12 = 0 ;
5661 PyObject *swig_obj[12] ;
5662
5663 (void)self;
5664 if (!SWIG_Python_UnpackTuple(args, "plbox3", 12, 12, swig_obj)) SWIG_fail;
5665 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5666 if (!SWIG_IsOK(res1)) {
5667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5668 }
5669 arg1 = (char *)(buf1);
5670 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
5671 if (!SWIG_IsOK(res2)) {
5672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5673 }
5674 arg2 = (char *)(buf2);
5675 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5676 if (!SWIG_IsOK(ecode3)) {
5677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5678 }
5679 arg3 = (PLFLT)(val3);
5680 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5681 if (!SWIG_IsOK(ecode4)) {
5682 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5683 }
5684 arg4 = (PLINT)(val4);
5685 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
5686 if (!SWIG_IsOK(res5)) {
5687 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5688 }
5689 arg5 = (char *)(buf5);
5690 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5691 if (!SWIG_IsOK(res6)) {
5692 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5693 }
5694 arg6 = (char *)(buf6);
5695 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5696 if (!SWIG_IsOK(ecode7)) {
5697 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5698 }
5699 arg7 = (PLFLT)(val7);
5700 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5701 if (!SWIG_IsOK(ecode8)) {
5702 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5703 }
5704 arg8 = (PLINT)(val8);
5705 res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
5706 if (!SWIG_IsOK(res9)) {
5707 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5708 }
5709 arg9 = (char *)(buf9);
5710 res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
5711 if (!SWIG_IsOK(res10)) {
5712 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5713 }
5714 arg10 = (char *)(buf10);
5715 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5716 if (!SWIG_IsOK(ecode11)) {
5717 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5718 }
5719 arg11 = (PLFLT)(val11);
5720 ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
5721 if (!SWIG_IsOK(ecode12)) {
5722 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5723 }
5724 arg12 = (PLINT)(val12);
5725 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);
5726 resultobj = SWIG_Py_Void();
5727 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5728 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5729 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5730 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5731 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5732 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5733 return resultobj;
5734fail:
5735 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5736 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5737 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5738 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5739 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5740 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5741 return NULL;
5742}
5743
5744
5745SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *self, PyObject *args) {
5746 PyObject *resultobj = 0;
5747 PLFLT arg1 ;
5748 PLFLT arg2 ;
5749 PLFLT *arg3 = (PLFLT *) 0 ;
5750 PLFLT *arg4 = (PLFLT *) 0 ;
5751 PLINT *arg5 = (PLINT *) 0 ;
5752 double val1 ;
5753 int ecode1 = 0 ;
5754 double val2 ;
5755 int ecode2 = 0 ;
5756 PLFLT temp3 ;
5757 int res3 = SWIG_TMPOBJ ;
5758 PLFLT temp4 ;
5759 int res4 = SWIG_TMPOBJ ;
5760 PLINT temp5 ;
5761 int res5 = SWIG_TMPOBJ ;
5762 PyObject *swig_obj[2] ;
5763
5764 arg3 = &temp3;
5765 arg4 = &temp4;
5766 arg5 = &temp5;
5767 (void)self;
5768 if (!SWIG_Python_UnpackTuple(args, "plcalc_world", 2, 2, swig_obj)) SWIG_fail;
5769 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5770 if (!SWIG_IsOK(ecode1)) {
5771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5772 }
5773 arg1 = (PLFLT)(val1);
5774 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5775 if (!SWIG_IsOK(ecode2)) {
5776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5777 }
5778 arg2 = (PLFLT)(val2);
5779 plcalc_world(arg1,arg2,arg3,arg4,arg5);
5780 resultobj = SWIG_Py_Void();
5781 if (SWIG_IsTmpObj(res3)) {
5782 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5783 } else {
5784 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5785 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5786 }
5787 if (SWIG_IsTmpObj(res4)) {
5788 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5789 } else {
5790 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5792 }
5793 if (SWIG_IsTmpObj(res5)) {
5794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5795 } else {
5796 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5798 }
5799 return resultobj;
5800fail:
5801 return NULL;
5802}
5803
5804
5805SWIGINTERN PyObject *_wrap_plclear(PyObject *self, PyObject *args) {
5806 PyObject *resultobj = 0;
5807
5808 (void)self;
5809 if (!SWIG_Python_UnpackTuple(args, "plclear", 0, 0, 0)) SWIG_fail;
5810 plclear();
5811 resultobj = SWIG_Py_Void();
5812 return resultobj;
5813fail:
5814 return NULL;
5815}
5816
5817
5818SWIGINTERN PyObject *_wrap_plcol0(PyObject *self, PyObject *args) {
5819 PyObject *resultobj = 0;
5820 PLINT arg1 ;
5821 int val1 ;
5822 int ecode1 = 0 ;
5823 PyObject *swig_obj[1] ;
5824
5825 (void)self;
5826 if (!args) SWIG_fail;
5827 swig_obj[0] = args;
5828 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5829 if (!SWIG_IsOK(ecode1)) {
5830 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5831 }
5832 arg1 = (PLINT)(val1);
5833 plcol0(arg1);
5834 resultobj = SWIG_Py_Void();
5835 return resultobj;
5836fail:
5837 return NULL;
5838}
5839
5840
5841SWIGINTERN PyObject *_wrap_plcol1(PyObject *self, PyObject *args) {
5842 PyObject *resultobj = 0;
5843 PLFLT arg1 ;
5844 double val1 ;
5845 int ecode1 = 0 ;
5846 PyObject *swig_obj[1] ;
5847
5848 (void)self;
5849 if (!args) SWIG_fail;
5850 swig_obj[0] = args;
5851 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5852 if (!SWIG_IsOK(ecode1)) {
5853 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5854 }
5855 arg1 = (PLFLT)(val1);
5856 plcol1(arg1);
5857 resultobj = SWIG_Py_Void();
5858 return resultobj;
5859fail:
5860 return NULL;
5861}
5862
5863
5864SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *self, PyObject *args) {
5865 PyObject *resultobj = 0;
5866 PLFLT arg1 ;
5867 PLFLT arg2 ;
5868 PLFLT arg3 ;
5869 PLINT arg4 ;
5870 PLBOOL arg5 ;
5871 PLINT arg6 ;
5872 PLINT arg7 ;
5873 PLINT arg8 ;
5874 PLINT arg9 ;
5875 PLINT arg10 ;
5876 PLFLT arg11 ;
5877 double val1 ;
5878 int ecode1 = 0 ;
5879 double val2 ;
5880 int ecode2 = 0 ;
5881 double val3 ;
5882 int ecode3 = 0 ;
5883 int val4 ;
5884 int ecode4 = 0 ;
5885 int val5 ;
5886 int ecode5 = 0 ;
5887 int val6 ;
5888 int ecode6 = 0 ;
5889 int val7 ;
5890 int ecode7 = 0 ;
5891 int val8 ;
5892 int ecode8 = 0 ;
5893 int val9 ;
5894 int ecode9 = 0 ;
5895 int val10 ;
5896 int ecode10 = 0 ;
5897 double val11 ;
5898 int ecode11 = 0 ;
5899 PyObject *swig_obj[11] ;
5900
5901 (void)self;
5902 if (!SWIG_Python_UnpackTuple(args, "plconfigtime", 11, 11, swig_obj)) SWIG_fail;
5903 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5904 if (!SWIG_IsOK(ecode1)) {
5905 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5906 }
5907 arg1 = (PLFLT)(val1);
5908 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5909 if (!SWIG_IsOK(ecode2)) {
5910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5911 }
5912 arg2 = (PLFLT)(val2);
5913 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5914 if (!SWIG_IsOK(ecode3)) {
5915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5916 }
5917 arg3 = (PLFLT)(val3);
5918 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5919 if (!SWIG_IsOK(ecode4)) {
5920 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5921 }
5922 arg4 = (PLINT)(val4);
5923 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5924 if (!SWIG_IsOK(ecode5)) {
5925 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5926 }
5927 arg5 = (PLBOOL)(val5);
5928 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5929 if (!SWIG_IsOK(ecode6)) {
5930 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5931 }
5932 arg6 = (PLINT)(val6);
5933 ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
5934 if (!SWIG_IsOK(ecode7)) {
5935 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5936 }
5937 arg7 = (PLINT)(val7);
5938 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5939 if (!SWIG_IsOK(ecode8)) {
5940 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5941 }
5942 arg8 = (PLINT)(val8);
5943 ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
5944 if (!SWIG_IsOK(ecode9)) {
5945 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5946 }
5947 arg9 = (PLINT)(val9);
5948 ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
5949 if (!SWIG_IsOK(ecode10)) {
5950 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5951 }
5952 arg10 = (PLINT)(val10);
5953 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5954 if (!SWIG_IsOK(ecode11)) {
5955 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5956 }
5957 arg11 = (PLFLT)(val11);
5958 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5959 resultobj = SWIG_Py_Void();
5960 return resultobj;
5961fail:
5962 return NULL;
5963}
5964
5965
5966SWIGINTERN PyObject *_wrap_plcont(PyObject *self, PyObject *args) {
5967 PyObject *resultobj = 0;
5968 PLFLT **arg1 = (PLFLT **) 0 ;
5969 PLINT arg2 ;
5970 PLINT arg3 ;
5971 PLINT arg4 ;
5972 PLINT arg5 ;
5973 PLINT arg6 ;
5974 PLINT arg7 ;
5975 PLFLT *arg8 = (PLFLT *) 0 ;
5976 PLINT arg9 ;
5977 pltr_func arg10 = (pltr_func) 0 ;
5978 PLPointer arg11 = (PLPointer) 0 ;
5979 PyArrayObject *tmp1 = NULL ;
5980 int val4 ;
5981 int ecode4 = 0 ;
5982 int val5 ;
5983 int ecode5 = 0 ;
5984 int val6 ;
5985 int ecode6 = 0 ;
5986 int val7 ;
5987 int ecode7 = 0 ;
5988 PyArrayObject *tmp8 = NULL ;
5989 PyObject *swig_obj[8] ;
5990
5991 {
5992 python_pltr = 0;
5993 arg10 = NULL;
5994 }
5995 {
5996 arg11 = NULL;
5997 }
5998 (void)self;
5999 if (!SWIG_Python_UnpackTuple(args, "plcont", 6, 8, swig_obj)) SWIG_fail;
6000 {
6001 int i, size;
6002 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
6003 if ( tmp1 == NULL )
6004 return NULL;
6005 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
6006 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
6007 size = arg3;
6008 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
6009 for ( i = 0; i < arg2; i++ )
6010 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
6011 }
6012 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
6013 if (!SWIG_IsOK(ecode4)) {
6014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
6015 }
6016 arg4 = (PLINT)(val4);
6017 ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
6018 if (!SWIG_IsOK(ecode5)) {
6019 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
6020 }
6021 arg5 = (PLINT)(val5);
6022 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
6023 if (!SWIG_IsOK(ecode6)) {
6024 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
6025 }
6026 arg6 = (PLINT)(val6);
6027 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
6028 if (!SWIG_IsOK(ecode7)) {
6029 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
6030 }
6031 arg7 = (PLINT)(val7);
6032 {
6033 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
6034 if ( tmp8 == NULL )
6035 return NULL;
6036 arg9 = PyArray_DIMS( tmp8 )[0];
6037 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
6038 }
6039 if (swig_obj[6]) {
6040 {
6041 // it must be a callable or None
6042 if ( swig_obj[6] == Py_None )
6043 {
6044 arg10 = NULL;
6045 }
6046 else
6047 {
6048 if ( !PyCallable_Check( (PyObject *) swig_obj[6] ) )
6049 {
6050 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
6051 return NULL;
6052 }
6053 arg10 = marshal_pltr( swig_obj[6] );
6054 }
6055 }
6056 }
6057 if (swig_obj[7]) {
6058 {
6059 if ( swig_obj[7] == Py_None )
6060 arg11 = NULL;
6061 else
6062 {
6063 arg11 = marshal_PLPointer( swig_obj[7], 0 );
6064 }
6065 }
6066 }
6067 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
6068 resultobj = SWIG_Py_Void();
6069 {
6070 Py_CLEAR( tmp1 );
6071 free( arg1 );
6072 }
6073 {
6074 Py_CLEAR( tmp8 );
6075 }
6076 {
6077 cleanup_pltr();
6078 }
6079 {
6081 }
6082 return resultobj;
6083fail:
6084 {
6085 Py_CLEAR( tmp1 );
6086 free( arg1 );
6087 }
6088 {
6089 Py_CLEAR( tmp8 );
6090 }
6091 {
6092 cleanup_pltr();
6093 }
6094 {
6096 }
6097 return NULL;
6098}
6099
6100
6101SWIGINTERN PyObject *_wrap_plctime(PyObject *self, PyObject *args) {
6102 PyObject *resultobj = 0;
6103 PLINT arg1 ;
6104 PLINT arg2 ;
6105 PLINT arg3 ;
6106 PLINT arg4 ;
6107 PLINT arg5 ;
6108 PLFLT arg6 ;
6109 PLFLT *arg7 = (PLFLT *) 0 ;
6110 int val1 ;
6111 int ecode1 = 0 ;
6112 int val2 ;
6113 int ecode2 = 0 ;
6114 int val3 ;
6115 int ecode3 = 0 ;
6116 int val4 ;
6117 int ecode4 = 0 ;
6118 int val5 ;
6119 int ecode5 = 0 ;
6120 double val6 ;
6121 int ecode6 = 0 ;
6122 PLFLT temp7 ;
6123 int res7 = SWIG_TMPOBJ ;
6124 PyObject *swig_obj[6] ;
6125
6126 arg7 = &temp7;
6127 (void)self;
6128 if (!SWIG_Python_UnpackTuple(args, "plctime", 6, 6, swig_obj)) SWIG_fail;
6129 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6130 if (!SWIG_IsOK(ecode1)) {
6131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
6132 }
6133 arg1 = (PLINT)(val1);
6134 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6135 if (!SWIG_IsOK(ecode2)) {
6136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
6137 }
6138 arg2 = (PLINT)(val2);
6139 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
6140 if (!SWIG_IsOK(ecode3)) {
6141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
6142 }
6143 arg3 = (PLINT)(val3);
6144 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
6145 if (!SWIG_IsOK(ecode4)) {
6146 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
6147 }
6148 arg4 = (PLINT)(val4);
6149 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6150 if (!SWIG_IsOK(ecode5)) {
6151 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
6152 }
6153 arg5 = (PLINT)(val5);
6154 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
6155 if (!SWIG_IsOK(ecode6)) {
6156 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
6157 }
6158 arg6 = (PLFLT)(val6);
6159 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
6160 resultobj = SWIG_Py_Void();
6161 if (SWIG_IsTmpObj(res7)) {
6162 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
6163 } else {
6164 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6165 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
6166 }
6167 return resultobj;
6168fail:
6169 return NULL;
6170}
6171
6172
6173SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *self, PyObject *args) {
6174 PyObject *resultobj = 0;
6175 PLINT arg1 ;
6176 PLBOOL arg2 ;
6177 int val1 ;
6178 int ecode1 = 0 ;
6179 int val2 ;
6180 int ecode2 = 0 ;
6181 PyObject *swig_obj[2] ;
6182
6183 (void)self;
6184 if (!SWIG_Python_UnpackTuple(args, "plcpstrm", 2, 2, swig_obj)) SWIG_fail;
6185 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6186 if (!SWIG_IsOK(ecode1)) {
6187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
6188 }
6189 arg1 = (PLINT)(val1);
6190 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6191 if (!SWIG_IsOK(ecode2)) {
6192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
6193 }
6194 arg2 = (PLBOOL)(val2);
6195 plcpstrm(arg1,arg2);
6196 resultobj = SWIG_Py_Void();
6197 return resultobj;
6198fail:
6199 return NULL;
6200}
6201
6202
6203SWIGINTERN PyObject *_wrap_plend(PyObject *self, PyObject *args) {
6204 PyObject *resultobj = 0;
6205
6206 (void)self;
6207 if (!SWIG_Python_UnpackTuple(args, "plend", 0, 0, 0)) SWIG_fail;
6208 plend();
6209 resultobj = SWIG_Py_Void();
6210 return resultobj;
6211fail:
6212 return NULL;
6213}
6214
6215
6216SWIGINTERN PyObject *_wrap_plend1(PyObject *self, PyObject *args) {
6217 PyObject *resultobj = 0;
6218
6219 (void)self;
6220 if (!SWIG_Python_UnpackTuple(args, "plend1", 0, 0, 0)) SWIG_fail;
6221 plend1();
6222 resultobj = SWIG_Py_Void();
6223 return resultobj;
6224fail:
6225 return NULL;
6226}
6227
6228
6229SWIGINTERN PyObject *_wrap_plenv(PyObject *self, PyObject *args) {
6230 PyObject *resultobj = 0;
6231 PLFLT arg1 ;
6232 PLFLT arg2 ;
6233 PLFLT arg3 ;
6234 PLFLT arg4 ;
6235 PLINT arg5 ;
6236 PLINT arg6 ;
6237 double val1 ;
6238 int ecode1 = 0 ;
6239 double val2 ;
6240 int ecode2 = 0 ;
6241 double val3 ;
6242 int ecode3 = 0 ;
6243 double val4 ;
6244 int ecode4 = 0 ;
6245 int val5 ;
6246 int ecode5 = 0 ;
6247 int val6 ;
6248 int ecode6 = 0 ;
6249 PyObject *swig_obj[6] ;
6250
6251 (void)self;
6252 if (!SWIG_Python_UnpackTuple(args, "plenv", 6, 6, swig_obj)) SWIG_fail;
6253 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6254 if (!SWIG_IsOK(ecode1)) {
6255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
6256 }
6257 arg1 = (PLFLT)(val1);
6258 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6259 if (!SWIG_IsOK(ecode2)) {
6260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
6261 }
6262 arg2 = (PLFLT)(val2);
6263 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6264 if (!SWIG_IsOK(ecode3)) {
6265 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
6266 }
6267 arg3 = (PLFLT)(val3);
6268 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6269 if (!SWIG_IsOK(ecode4)) {
6270 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
6271 }
6272 arg4 = (PLFLT)(val4);
6273 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6274 if (!SWIG_IsOK(ecode5)) {
6275 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
6276 }
6277 arg5 = (PLINT)(val5);
6278 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6279 if (!SWIG_IsOK(ecode6)) {
6280 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6281 }
6282 arg6 = (PLINT)(val6);
6283 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6284 resultobj = SWIG_Py_Void();
6285 return resultobj;
6286fail:
6287 return NULL;
6288}
6289
6290
6291SWIGINTERN PyObject *_wrap_plenv0(PyObject *self, PyObject *args) {
6292 PyObject *resultobj = 0;
6293 PLFLT arg1 ;
6294 PLFLT arg2 ;
6295 PLFLT arg3 ;
6296 PLFLT arg4 ;
6297 PLINT arg5 ;
6298 PLINT arg6 ;
6299 double val1 ;
6300 int ecode1 = 0 ;
6301 double val2 ;
6302 int ecode2 = 0 ;
6303 double val3 ;
6304 int ecode3 = 0 ;
6305 double val4 ;
6306 int ecode4 = 0 ;
6307 int val5 ;
6308 int ecode5 = 0 ;
6309 int val6 ;
6310 int ecode6 = 0 ;
6311 PyObject *swig_obj[6] ;
6312
6313 (void)self;
6314 if (!SWIG_Python_UnpackTuple(args, "plenv0", 6, 6, swig_obj)) SWIG_fail;
6315 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6316 if (!SWIG_IsOK(ecode1)) {
6317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6318 }
6319 arg1 = (PLFLT)(val1);
6320 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6321 if (!SWIG_IsOK(ecode2)) {
6322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6323 }
6324 arg2 = (PLFLT)(val2);
6325 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6326 if (!SWIG_IsOK(ecode3)) {
6327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6328 }
6329 arg3 = (PLFLT)(val3);
6330 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6331 if (!SWIG_IsOK(ecode4)) {
6332 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6333 }
6334 arg4 = (PLFLT)(val4);
6335 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6336 if (!SWIG_IsOK(ecode5)) {
6337 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6338 }
6339 arg5 = (PLINT)(val5);
6340 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6341 if (!SWIG_IsOK(ecode6)) {
6342 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6343 }
6344 arg6 = (PLINT)(val6);
6345 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6346 resultobj = SWIG_Py_Void();
6347 return resultobj;
6348fail:
6349 return NULL;
6350}
6351
6352
6353SWIGINTERN PyObject *_wrap_pleop(PyObject *self, PyObject *args) {
6354 PyObject *resultobj = 0;
6355
6356 (void)self;
6357 if (!SWIG_Python_UnpackTuple(args, "pleop", 0, 0, 0)) SWIG_fail;
6358 pleop();
6359 resultobj = SWIG_Py_Void();
6360 return resultobj;
6361fail:
6362 return NULL;
6363}
6364
6365
6366SWIGINTERN PyObject *_wrap_plerrx(PyObject *self, PyObject *args) {
6367 PyObject *resultobj = 0;
6368 PLINT arg1 ;
6369 PLFLT *arg2 = (PLFLT *) 0 ;
6370 PLFLT *arg3 = (PLFLT *) 0 ;
6371 PLFLT *arg4 = (PLFLT *) 0 ;
6372 PyArrayObject *tmp1 = NULL ;
6373 PyArrayObject *tmp3 = NULL ;
6374 PyArrayObject *tmp4 = NULL ;
6375 PyObject *swig_obj[3] ;
6376
6377 (void)self;
6378 if (!SWIG_Python_UnpackTuple(args, "plerrx", 3, 3, swig_obj)) SWIG_fail;
6379 {
6380 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6381 if ( tmp1 == NULL )
6382 return NULL;
6383 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6384 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6385 }
6386 {
6387 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6388 if ( tmp3 == NULL )
6389 return NULL;
6390 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6391 {
6392 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6393 return NULL;
6394 }
6395 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6396 }
6397 {
6398 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6399 if ( tmp4 == NULL )
6400 return NULL;
6401 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6402 {
6403 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6404 return NULL;
6405 }
6406 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6407 }
6408 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6409 resultobj = SWIG_Py_Void();
6410 {
6411 Py_CLEAR( tmp1 );
6412 }
6413 {
6414 Py_CLEAR( tmp3 );
6415 }
6416 {
6417 Py_CLEAR( tmp4 );
6418 }
6419 return resultobj;
6420fail:
6421 {
6422 Py_CLEAR( tmp1 );
6423 }
6424 {
6425 Py_CLEAR( tmp3 );
6426 }
6427 {
6428 Py_CLEAR( tmp4 );
6429 }
6430 return NULL;
6431}
6432
6433
6434SWIGINTERN PyObject *_wrap_plerry(PyObject *self, PyObject *args) {
6435 PyObject *resultobj = 0;
6436 PLINT arg1 ;
6437 PLFLT *arg2 = (PLFLT *) 0 ;
6438 PLFLT *arg3 = (PLFLT *) 0 ;
6439 PLFLT *arg4 = (PLFLT *) 0 ;
6440 PyArrayObject *tmp1 = NULL ;
6441 PyArrayObject *tmp3 = NULL ;
6442 PyArrayObject *tmp4 = NULL ;
6443 PyObject *swig_obj[3] ;
6444
6445 (void)self;
6446 if (!SWIG_Python_UnpackTuple(args, "plerry", 3, 3, swig_obj)) SWIG_fail;
6447 {
6448 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6449 if ( tmp1 == NULL )
6450 return NULL;
6451 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6452 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6453 }
6454 {
6455 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6456 if ( tmp3 == NULL )
6457 return NULL;
6458 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6459 {
6460 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6461 return NULL;
6462 }
6463 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6464 }
6465 {
6466 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6467 if ( tmp4 == NULL )
6468 return NULL;
6469 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6470 {
6471 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6472 return NULL;
6473 }
6474 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6475 }
6476 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6477 resultobj = SWIG_Py_Void();
6478 {
6479 Py_CLEAR( tmp1 );
6480 }
6481 {
6482 Py_CLEAR( tmp3 );
6483 }
6484 {
6485 Py_CLEAR( tmp4 );
6486 }
6487 return resultobj;
6488fail:
6489 {
6490 Py_CLEAR( tmp1 );
6491 }
6492 {
6493 Py_CLEAR( tmp3 );
6494 }
6495 {
6496 Py_CLEAR( tmp4 );
6497 }
6498 return NULL;
6499}
6500
6501
6502SWIGINTERN PyObject *_wrap_plfamadv(PyObject *self, PyObject *args) {
6503 PyObject *resultobj = 0;
6504
6505 (void)self;
6506 if (!SWIG_Python_UnpackTuple(args, "plfamadv", 0, 0, 0)) SWIG_fail;
6507 plfamadv();
6508 resultobj = SWIG_Py_Void();
6509 return resultobj;
6510fail:
6511 return NULL;
6512}
6513
6514
6515SWIGINTERN PyObject *_wrap_plfill(PyObject *self, PyObject *args) {
6516 PyObject *resultobj = 0;
6517 PLINT arg1 ;
6518 PLFLT *arg2 = (PLFLT *) 0 ;
6519 PLFLT *arg3 = (PLFLT *) 0 ;
6520 PyArrayObject *tmp1 = NULL ;
6521 PyArrayObject *tmp3 = NULL ;
6522 PyObject *swig_obj[2] ;
6523
6524 (void)self;
6525 if (!SWIG_Python_UnpackTuple(args, "plfill", 2, 2, swig_obj)) SWIG_fail;
6526 {
6527 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6528 if ( tmp1 == NULL )
6529 return NULL;
6530 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6531 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6532 }
6533 {
6534 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6535 if ( tmp3 == NULL )
6536 return NULL;
6537 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6538 {
6539 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6540 return NULL;
6541 }
6542 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6543 }
6544 plfill(arg1,(double const *)arg2,(double const *)arg3);
6545 resultobj = SWIG_Py_Void();
6546 {
6547 Py_CLEAR( tmp1 );
6548 }
6549 {
6550 Py_CLEAR( tmp3 );
6551 }
6552 return resultobj;
6553fail:
6554 {
6555 Py_CLEAR( tmp1 );
6556 }
6557 {
6558 Py_CLEAR( tmp3 );
6559 }
6560 return NULL;
6561}
6562
6563
6564SWIGINTERN PyObject *_wrap_plfill3(PyObject *self, PyObject *args) {
6565 PyObject *resultobj = 0;
6566 PLINT arg1 ;
6567 PLFLT *arg2 = (PLFLT *) 0 ;
6568 PLFLT *arg3 = (PLFLT *) 0 ;
6569 PLFLT *arg4 = (PLFLT *) 0 ;
6570 PyArrayObject *tmp1 = NULL ;
6571 PyArrayObject *tmp3 = NULL ;
6572 PyArrayObject *tmp4 = NULL ;
6573 PyObject *swig_obj[3] ;
6574
6575 (void)self;
6576 if (!SWIG_Python_UnpackTuple(args, "plfill3", 3, 3, swig_obj)) SWIG_fail;
6577 {
6578 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6579 if ( tmp1 == NULL )
6580 return NULL;
6581 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6582 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6583 }
6584 {
6585 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6586 if ( tmp3 == NULL )
6587 return NULL;
6588 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6589 {
6590 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6591 return NULL;
6592 }
6593 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6594 }
6595 {
6596 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6597 if ( tmp4 == NULL )
6598 return NULL;
6599 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6600 {
6601 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6602 return NULL;
6603 }
6604 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6605 }
6606 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6607 resultobj = SWIG_Py_Void();
6608 {
6609 Py_CLEAR( tmp1 );
6610 }
6611 {
6612 Py_CLEAR( tmp3 );
6613 }
6614 {
6615 Py_CLEAR( tmp4 );
6616 }
6617 return resultobj;
6618fail:
6619 {
6620 Py_CLEAR( tmp1 );
6621 }
6622 {
6623 Py_CLEAR( tmp3 );
6624 }
6625 {
6626 Py_CLEAR( tmp4 );
6627 }
6628 return NULL;
6629}
6630
6631
6632SWIGINTERN PyObject *_wrap_plgradient(PyObject *self, PyObject *args) {
6633 PyObject *resultobj = 0;
6634 PLINT arg1 ;
6635 PLFLT *arg2 = (PLFLT *) 0 ;
6636 PLFLT *arg3 = (PLFLT *) 0 ;
6637 PLFLT arg4 ;
6638 PyArrayObject *tmp1 = NULL ;
6639 PyArrayObject *tmp3 = NULL ;
6640 double val4 ;
6641 int ecode4 = 0 ;
6642 PyObject *swig_obj[3] ;
6643
6644 (void)self;
6645 if (!SWIG_Python_UnpackTuple(args, "plgradient", 3, 3, swig_obj)) SWIG_fail;
6646 {
6647 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6648 if ( tmp1 == NULL )
6649 return NULL;
6650 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6651 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6652 }
6653 {
6654 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6655 if ( tmp3 == NULL )
6656 return NULL;
6657 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6658 {
6659 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6660 return NULL;
6661 }
6662 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6663 }
6664 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
6665 if (!SWIG_IsOK(ecode4)) {
6666 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6667 }
6668 arg4 = (PLFLT)(val4);
6669 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6670 resultobj = SWIG_Py_Void();
6671 {
6672 Py_CLEAR( tmp1 );
6673 }
6674 {
6675 Py_CLEAR( tmp3 );
6676 }
6677 return resultobj;
6678fail:
6679 {
6680 Py_CLEAR( tmp1 );
6681 }
6682 {
6683 Py_CLEAR( tmp3 );
6684 }
6685 return NULL;
6686}
6687
6688
6689SWIGINTERN PyObject *_wrap_plflush(PyObject *self, PyObject *args) {
6690 PyObject *resultobj = 0;
6691
6692 (void)self;
6693 if (!SWIG_Python_UnpackTuple(args, "plflush", 0, 0, 0)) SWIG_fail;
6694 plflush();
6695 resultobj = SWIG_Py_Void();
6696 return resultobj;
6697fail:
6698 return NULL;
6699}
6700
6701
6702SWIGINTERN PyObject *_wrap_plfont(PyObject *self, PyObject *args) {
6703 PyObject *resultobj = 0;
6704 PLINT arg1 ;
6705 int val1 ;
6706 int ecode1 = 0 ;
6707 PyObject *swig_obj[1] ;
6708
6709 (void)self;
6710 if (!args) SWIG_fail;
6711 swig_obj[0] = args;
6712 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6713 if (!SWIG_IsOK(ecode1)) {
6714 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6715 }
6716 arg1 = (PLINT)(val1);
6717 plfont(arg1);
6718 resultobj = SWIG_Py_Void();
6719 return resultobj;
6720fail:
6721 return NULL;
6722}
6723
6724
6725SWIGINTERN PyObject *_wrap_plfontld(PyObject *self, PyObject *args) {
6726 PyObject *resultobj = 0;
6727 PLINT arg1 ;
6728 int val1 ;
6729 int ecode1 = 0 ;
6730 PyObject *swig_obj[1] ;
6731
6732 (void)self;
6733 if (!args) SWIG_fail;
6734 swig_obj[0] = args;
6735 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6736 if (!SWIG_IsOK(ecode1)) {
6737 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6738 }
6739 arg1 = (PLINT)(val1);
6740 plfontld(arg1);
6741 resultobj = SWIG_Py_Void();
6742 return resultobj;
6743fail:
6744 return NULL;
6745}
6746
6747
6748SWIGINTERN PyObject *_wrap_plgchr(PyObject *self, PyObject *args) {
6749 PyObject *resultobj = 0;
6750 PLFLT *arg1 = (PLFLT *) 0 ;
6751 PLFLT *arg2 = (PLFLT *) 0 ;
6752 PLFLT temp1 ;
6753 int res1 = SWIG_TMPOBJ ;
6754 PLFLT temp2 ;
6755 int res2 = SWIG_TMPOBJ ;
6756
6757 arg1 = &temp1;
6758 arg2 = &temp2;
6759 (void)self;
6760 if (!SWIG_Python_UnpackTuple(args, "plgchr", 0, 0, 0)) SWIG_fail;
6761 plgchr(arg1,arg2);
6762 resultobj = SWIG_Py_Void();
6763 if (SWIG_IsTmpObj(res1)) {
6764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6765 } else {
6766 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6767 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6768 }
6769 if (SWIG_IsTmpObj(res2)) {
6770 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6771 } else {
6772 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6774 }
6775 return resultobj;
6776fail:
6777 return NULL;
6778}
6779
6780
6781SWIGINTERN PyObject *_wrap_plgcol0(PyObject *self, PyObject *args) {
6782 PyObject *resultobj = 0;
6783 PLINT arg1 ;
6784 PLINT *arg2 = (PLINT *) 0 ;
6785 PLINT *arg3 = (PLINT *) 0 ;
6786 PLINT *arg4 = (PLINT *) 0 ;
6787 int val1 ;
6788 int ecode1 = 0 ;
6789 PLINT temp2 ;
6790 int res2 = SWIG_TMPOBJ ;
6791 PLINT temp3 ;
6792 int res3 = SWIG_TMPOBJ ;
6793 PLINT temp4 ;
6794 int res4 = SWIG_TMPOBJ ;
6795 PyObject *swig_obj[1] ;
6796
6797 arg2 = &temp2;
6798 arg3 = &temp3;
6799 arg4 = &temp4;
6800 (void)self;
6801 if (!args) SWIG_fail;
6802 swig_obj[0] = args;
6803 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6804 if (!SWIG_IsOK(ecode1)) {
6805 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6806 }
6807 arg1 = (PLINT)(val1);
6808 plgcol0(arg1,arg2,arg3,arg4);
6809 resultobj = SWIG_Py_Void();
6810 if (SWIG_IsTmpObj(res2)) {
6811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6812 } else {
6813 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6815 }
6816 if (SWIG_IsTmpObj(res3)) {
6817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6818 } else {
6819 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6821 }
6822 if (SWIG_IsTmpObj(res4)) {
6823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6824 } else {
6825 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6827 }
6828 return resultobj;
6829fail:
6830 return NULL;
6831}
6832
6833
6834SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *self, PyObject *args) {
6835 PyObject *resultobj = 0;
6836 PLINT arg1 ;
6837 PLINT *arg2 = (PLINT *) 0 ;
6838 PLINT *arg3 = (PLINT *) 0 ;
6839 PLINT *arg4 = (PLINT *) 0 ;
6840 PLFLT *arg5 = (PLFLT *) 0 ;
6841 int val1 ;
6842 int ecode1 = 0 ;
6843 PLINT temp2 ;
6844 int res2 = SWIG_TMPOBJ ;
6845 PLINT temp3 ;
6846 int res3 = SWIG_TMPOBJ ;
6847 PLINT temp4 ;
6848 int res4 = SWIG_TMPOBJ ;
6849 PLFLT temp5 ;
6850 int res5 = SWIG_TMPOBJ ;
6851 PyObject *swig_obj[1] ;
6852
6853 arg2 = &temp2;
6854 arg3 = &temp3;
6855 arg4 = &temp4;
6856 arg5 = &temp5;
6857 (void)self;
6858 if (!args) SWIG_fail;
6859 swig_obj[0] = args;
6860 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6861 if (!SWIG_IsOK(ecode1)) {
6862 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6863 }
6864 arg1 = (PLINT)(val1);
6865 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6866 resultobj = SWIG_Py_Void();
6867 if (SWIG_IsTmpObj(res2)) {
6868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6869 } else {
6870 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6872 }
6873 if (SWIG_IsTmpObj(res3)) {
6874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6875 } else {
6876 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6878 }
6879 if (SWIG_IsTmpObj(res4)) {
6880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6881 } else {
6882 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6884 }
6885 if (SWIG_IsTmpObj(res5)) {
6886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6887 } else {
6888 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6890 }
6891 return resultobj;
6892fail:
6893 return NULL;
6894}
6895
6896
6897SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *self, PyObject *args) {
6898 PyObject *resultobj = 0;
6899 PLINT *arg1 = (PLINT *) 0 ;
6900 PLINT *arg2 = (PLINT *) 0 ;
6901 PLINT *arg3 = (PLINT *) 0 ;
6902 PLINT temp1 ;
6903 int res1 = SWIG_TMPOBJ ;
6904 PLINT temp2 ;
6905 int res2 = SWIG_TMPOBJ ;
6906 PLINT temp3 ;
6907 int res3 = SWIG_TMPOBJ ;
6908
6909 arg1 = &temp1;
6910 arg2 = &temp2;
6911 arg3 = &temp3;
6912 (void)self;
6913 if (!SWIG_Python_UnpackTuple(args, "plgcolbg", 0, 0, 0)) SWIG_fail;
6914 plgcolbg(arg1,arg2,arg3);
6915 resultobj = SWIG_Py_Void();
6916 if (SWIG_IsTmpObj(res1)) {
6917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6918 } else {
6919 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6920 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6921 }
6922 if (SWIG_IsTmpObj(res2)) {
6923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6924 } else {
6925 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6927 }
6928 if (SWIG_IsTmpObj(res3)) {
6929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6930 } else {
6931 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6933 }
6934 return resultobj;
6935fail:
6936 return NULL;
6937}
6938
6939
6940SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *self, PyObject *args) {
6941 PyObject *resultobj = 0;
6942 PLINT *arg1 = (PLINT *) 0 ;
6943 PLINT *arg2 = (PLINT *) 0 ;
6944 PLINT *arg3 = (PLINT *) 0 ;
6945 PLFLT *arg4 = (PLFLT *) 0 ;
6946 PLINT temp1 ;
6947 int res1 = SWIG_TMPOBJ ;
6948 PLINT temp2 ;
6949 int res2 = SWIG_TMPOBJ ;
6950 PLINT temp3 ;
6951 int res3 = SWIG_TMPOBJ ;
6952 PLFLT temp4 ;
6953 int res4 = SWIG_TMPOBJ ;
6954
6955 arg1 = &temp1;
6956 arg2 = &temp2;
6957 arg3 = &temp3;
6958 arg4 = &temp4;
6959 (void)self;
6960 if (!SWIG_Python_UnpackTuple(args, "plgcolbga", 0, 0, 0)) SWIG_fail;
6961 plgcolbga(arg1,arg2,arg3,arg4);
6962 resultobj = SWIG_Py_Void();
6963 if (SWIG_IsTmpObj(res1)) {
6964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6965 } else {
6966 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6968 }
6969 if (SWIG_IsTmpObj(res2)) {
6970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6971 } else {
6972 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6974 }
6975 if (SWIG_IsTmpObj(res3)) {
6976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6977 } else {
6978 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6980 }
6981 if (SWIG_IsTmpObj(res4)) {
6982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6983 } else {
6984 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6986 }
6987 return resultobj;
6988fail:
6989 return NULL;
6990}
6991
6992
6993SWIGINTERN PyObject *_wrap_plgcompression(PyObject *self, PyObject *args) {
6994 PyObject *resultobj = 0;
6995 PLINT *arg1 = (PLINT *) 0 ;
6996 PLINT temp1 ;
6997 int res1 = SWIG_TMPOBJ ;
6998
6999 arg1 = &temp1;
7000 (void)self;
7001 if (!SWIG_Python_UnpackTuple(args, "plgcompression", 0, 0, 0)) SWIG_fail;
7002 plgcompression(arg1);
7003 resultobj = SWIG_Py_Void();
7004 if (SWIG_IsTmpObj(res1)) {
7005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7006 } else {
7007 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7009 }
7010 return resultobj;
7011fail:
7012 return NULL;
7013}
7014
7015
7016SWIGINTERN PyObject *_wrap_plgdev(PyObject *self, PyObject *args) {
7017 PyObject *resultobj = 0;
7018 char *arg1 = (char *) 0 ;
7019 char buff1[1000] ;
7020
7021 {
7022 arg1 = buff1;
7023 }
7024 (void)self;
7025 if (!SWIG_Python_UnpackTuple(args, "plgdev", 0, 0, 0)) SWIG_fail;
7026 plgdev(arg1);
7027 resultobj = SWIG_Py_Void();
7028 {
7029 PyObject *o = PyString_FromString( arg1 );
7030 resultobj = SWIG_Python_AppendOutput(resultobj, o);
7031 }
7032 return resultobj;
7033fail:
7034 return NULL;
7035}
7036
7037
7038SWIGINTERN PyObject *_wrap_plgdidev(PyObject *self, PyObject *args) {
7039 PyObject *resultobj = 0;
7040 PLFLT *arg1 = (PLFLT *) 0 ;
7041 PLFLT *arg2 = (PLFLT *) 0 ;
7042 PLFLT *arg3 = (PLFLT *) 0 ;
7043 PLFLT *arg4 = (PLFLT *) 0 ;
7044 PLFLT temp1 ;
7045 int res1 = SWIG_TMPOBJ ;
7046 PLFLT temp2 ;
7047 int res2 = SWIG_TMPOBJ ;
7048 PLFLT temp3 ;
7049 int res3 = SWIG_TMPOBJ ;
7050 PLFLT temp4 ;
7051 int res4 = SWIG_TMPOBJ ;
7052
7053 arg1 = &temp1;
7054 arg2 = &temp2;
7055 arg3 = &temp3;
7056 arg4 = &temp4;
7057 (void)self;
7058 if (!SWIG_Python_UnpackTuple(args, "plgdidev", 0, 0, 0)) SWIG_fail;
7059 plgdidev(arg1,arg2,arg3,arg4);
7060 resultobj = SWIG_Py_Void();
7061 if (SWIG_IsTmpObj(res1)) {
7062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7063 } else {
7064 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7066 }
7067 if (SWIG_IsTmpObj(res2)) {
7068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7069 } else {
7070 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7071 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7072 }
7073 if (SWIG_IsTmpObj(res3)) {
7074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7075 } else {
7076 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7078 }
7079 if (SWIG_IsTmpObj(res4)) {
7080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7081 } else {
7082 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7084 }
7085 return resultobj;
7086fail:
7087 return NULL;
7088}
7089
7090
7091SWIGINTERN PyObject *_wrap_plgdiori(PyObject *self, PyObject *args) {
7092 PyObject *resultobj = 0;
7093 PLFLT *arg1 = (PLFLT *) 0 ;
7094 PLFLT temp1 ;
7095 int res1 = SWIG_TMPOBJ ;
7096
7097 arg1 = &temp1;
7098 (void)self;
7099 if (!SWIG_Python_UnpackTuple(args, "plgdiori", 0, 0, 0)) SWIG_fail;
7100 plgdiori(arg1);
7101 resultobj = SWIG_Py_Void();
7102 if (SWIG_IsTmpObj(res1)) {
7103 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7104 } else {
7105 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7106 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7107 }
7108 return resultobj;
7109fail:
7110 return NULL;
7111}
7112
7113
7114SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *self, PyObject *args) {
7115 PyObject *resultobj = 0;
7116 PLFLT *arg1 = (PLFLT *) 0 ;
7117 PLFLT *arg2 = (PLFLT *) 0 ;
7118 PLFLT *arg3 = (PLFLT *) 0 ;
7119 PLFLT *arg4 = (PLFLT *) 0 ;
7120 PLFLT temp1 ;
7121 int res1 = SWIG_TMPOBJ ;
7122 PLFLT temp2 ;
7123 int res2 = SWIG_TMPOBJ ;
7124 PLFLT temp3 ;
7125 int res3 = SWIG_TMPOBJ ;
7126 PLFLT temp4 ;
7127 int res4 = SWIG_TMPOBJ ;
7128
7129 arg1 = &temp1;
7130 arg2 = &temp2;
7131 arg3 = &temp3;
7132 arg4 = &temp4;
7133 (void)self;
7134 if (!SWIG_Python_UnpackTuple(args, "plgdiplt", 0, 0, 0)) SWIG_fail;
7135 plgdiplt(arg1,arg2,arg3,arg4);
7136 resultobj = SWIG_Py_Void();
7137 if (SWIG_IsTmpObj(res1)) {
7138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7139 } else {
7140 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7142 }
7143 if (SWIG_IsTmpObj(res2)) {
7144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7145 } else {
7146 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7148 }
7149 if (SWIG_IsTmpObj(res3)) {
7150 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7151 } else {
7152 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7153 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7154 }
7155 if (SWIG_IsTmpObj(res4)) {
7156 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7157 } else {
7158 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7159 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7160 }
7161 return resultobj;
7162fail:
7163 return NULL;
7164}
7165
7166
7167SWIGINTERN PyObject *_wrap_plgfam(PyObject *self, PyObject *args) {
7168 PyObject *resultobj = 0;
7169 PLINT *arg1 = (PLINT *) 0 ;
7170 PLINT *arg2 = (PLINT *) 0 ;
7171 PLINT *arg3 = (PLINT *) 0 ;
7172 PLINT temp1 ;
7173 int res1 = SWIG_TMPOBJ ;
7174 PLINT temp2 ;
7175 int res2 = SWIG_TMPOBJ ;
7176 PLINT temp3 ;
7177 int res3 = SWIG_TMPOBJ ;
7178
7179 arg1 = &temp1;
7180 arg2 = &temp2;
7181 arg3 = &temp3;
7182 (void)self;
7183 if (!SWIG_Python_UnpackTuple(args, "plgfam", 0, 0, 0)) SWIG_fail;
7184 plgfam(arg1,arg2,arg3);
7185 resultobj = SWIG_Py_Void();
7186 if (SWIG_IsTmpObj(res1)) {
7187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7188 } else {
7189 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7191 }
7192 if (SWIG_IsTmpObj(res2)) {
7193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7194 } else {
7195 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7197 }
7198 if (SWIG_IsTmpObj(res3)) {
7199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7200 } else {
7201 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7203 }
7204 return resultobj;
7205fail:
7206 return NULL;
7207}
7208
7209
7210SWIGINTERN PyObject *_wrap_plgfci(PyObject *self, PyObject *args) {
7211 PyObject *resultobj = 0;
7212 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
7213 PLUNICODE temp1 ;
7214 int res1 = SWIG_TMPOBJ ;
7215
7216 arg1 = &temp1;
7217 (void)self;
7218 if (!SWIG_Python_UnpackTuple(args, "plgfci", 0, 0, 0)) SWIG_fail;
7219 plgfci(arg1);
7220 resultobj = SWIG_Py_Void();
7221 if (SWIG_IsTmpObj(res1)) {
7222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
7223 } else {
7224 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
7226 }
7227 return resultobj;
7228fail:
7229 return NULL;
7230}
7231
7232
7233SWIGINTERN PyObject *_wrap_plgfnam(PyObject *self, PyObject *args) {
7234 PyObject *resultobj = 0;
7235 char *arg1 = (char *) 0 ;
7236 char buff1[1000] ;
7237
7238 {
7239 arg1 = buff1;
7240 }
7241 (void)self;
7242 if (!SWIG_Python_UnpackTuple(args, "plgfnam", 0, 0, 0)) SWIG_fail;
7243 plgfnam(arg1);
7244 resultobj = SWIG_Py_Void();
7245 {
7246 PyObject *o = PyString_FromString( arg1 );
7247 resultobj = SWIG_Python_AppendOutput(resultobj, o);
7248 }
7249 return resultobj;
7250fail:
7251 return NULL;
7252}
7253
7254
7255SWIGINTERN PyObject *_wrap_plgfont(PyObject *self, PyObject *args) {
7256 PyObject *resultobj = 0;
7257 PLINT *arg1 = (PLINT *) 0 ;
7258 PLINT *arg2 = (PLINT *) 0 ;
7259 PLINT *arg3 = (PLINT *) 0 ;
7260 PLINT temp1 ;
7261 int res1 = SWIG_TMPOBJ ;
7262 PLINT temp2 ;
7263 int res2 = SWIG_TMPOBJ ;
7264 PLINT temp3 ;
7265 int res3 = SWIG_TMPOBJ ;
7266
7267 arg1 = &temp1;
7268 arg2 = &temp2;
7269 arg3 = &temp3;
7270 (void)self;
7271 if (!SWIG_Python_UnpackTuple(args, "plgfont", 0, 0, 0)) SWIG_fail;
7272 plgfont(arg1,arg2,arg3);
7273 resultobj = SWIG_Py_Void();
7274 if (SWIG_IsTmpObj(res1)) {
7275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7276 } else {
7277 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7278 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7279 }
7280 if (SWIG_IsTmpObj(res2)) {
7281 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7282 } else {
7283 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7285 }
7286 if (SWIG_IsTmpObj(res3)) {
7287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7288 } else {
7289 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7291 }
7292 return resultobj;
7293fail:
7294 return NULL;
7295}
7296
7297
7298SWIGINTERN PyObject *_wrap_plglevel(PyObject *self, PyObject *args) {
7299 PyObject *resultobj = 0;
7300 PLINT *arg1 = (PLINT *) 0 ;
7301 PLINT temp1 ;
7302 int res1 = SWIG_TMPOBJ ;
7303
7304 arg1 = &temp1;
7305 (void)self;
7306 if (!SWIG_Python_UnpackTuple(args, "plglevel", 0, 0, 0)) SWIG_fail;
7307 plglevel(arg1);
7308 resultobj = SWIG_Py_Void();
7309 if (SWIG_IsTmpObj(res1)) {
7310 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7311 } else {
7312 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7313 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7314 }
7315 return resultobj;
7316fail:
7317 return NULL;
7318}
7319
7320
7321SWIGINTERN PyObject *_wrap_plgpage(PyObject *self, PyObject *args) {
7322 PyObject *resultobj = 0;
7323 PLFLT *arg1 = (PLFLT *) 0 ;
7324 PLFLT *arg2 = (PLFLT *) 0 ;
7325 PLINT *arg3 = (PLINT *) 0 ;
7326 PLINT *arg4 = (PLINT *) 0 ;
7327 PLINT *arg5 = (PLINT *) 0 ;
7328 PLINT *arg6 = (PLINT *) 0 ;
7329 PLFLT temp1 ;
7330 int res1 = SWIG_TMPOBJ ;
7331 PLFLT temp2 ;
7332 int res2 = SWIG_TMPOBJ ;
7333 PLINT temp3 ;
7334 int res3 = SWIG_TMPOBJ ;
7335 PLINT temp4 ;
7336 int res4 = SWIG_TMPOBJ ;
7337 PLINT temp5 ;
7338 int res5 = SWIG_TMPOBJ ;
7339 PLINT temp6 ;
7340 int res6 = SWIG_TMPOBJ ;
7341
7342 arg1 = &temp1;
7343 arg2 = &temp2;
7344 arg3 = &temp3;
7345 arg4 = &temp4;
7346 arg5 = &temp5;
7347 arg6 = &temp6;
7348 (void)self;
7349 if (!SWIG_Python_UnpackTuple(args, "plgpage", 0, 0, 0)) SWIG_fail;
7350 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7351 resultobj = SWIG_Py_Void();
7352 if (SWIG_IsTmpObj(res1)) {
7353 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7354 } else {
7355 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7356 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7357 }
7358 if (SWIG_IsTmpObj(res2)) {
7359 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7360 } else {
7361 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7363 }
7364 if (SWIG_IsTmpObj(res3)) {
7365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7366 } else {
7367 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7369 }
7370 if (SWIG_IsTmpObj(res4)) {
7371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
7372 } else {
7373 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7375 }
7376 if (SWIG_IsTmpObj(res5)) {
7377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
7378 } else {
7379 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7381 }
7382 if (SWIG_IsTmpObj(res6)) {
7383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
7384 } else {
7385 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
7387 }
7388 return resultobj;
7389fail:
7390 return NULL;
7391}
7392
7393
7394SWIGINTERN PyObject *_wrap_plgra(PyObject *self, PyObject *args) {
7395 PyObject *resultobj = 0;
7396
7397 (void)self;
7398 if (!SWIG_Python_UnpackTuple(args, "plgra", 0, 0, 0)) SWIG_fail;
7399 plgra();
7400 resultobj = SWIG_Py_Void();
7401 return resultobj;
7402fail:
7403 return NULL;
7404}
7405
7406
7407SWIGINTERN PyObject *_wrap_plgriddata(PyObject *self, PyObject *args) {
7408 PyObject *resultobj = 0;
7409 PLFLT *arg1 = (PLFLT *) 0 ;
7410 PLFLT *arg2 = (PLFLT *) 0 ;
7411 PLFLT *arg3 = (PLFLT *) 0 ;
7412 PLINT arg4 ;
7413 PLFLT *arg5 = (PLFLT *) 0 ;
7414 PLINT arg6 ;
7415 PLFLT *arg7 = (PLFLT *) 0 ;
7416 PLINT arg8 ;
7417 PLFLT **arg9 = (PLFLT **) 0 ;
7418 PLINT arg10 ;
7419 PLFLT arg11 ;
7420 PyArrayObject *tmp1 = NULL ;
7421 PyArrayObject *tmp2 = NULL ;
7422 PyArrayObject *tmp3 = NULL ;
7423 PyArrayObject *tmp5 = NULL ;
7424 PyArrayObject *tmp7 = NULL ;
7425 PyObject *array7 = NULL ;
7426 int val10 ;
7427 int ecode10 = 0 ;
7428 double val11 ;
7429 int ecode11 = 0 ;
7430 PyObject *swig_obj[7] ;
7431
7432 (void)self;
7433 if (!SWIG_Python_UnpackTuple(args, "plgriddata", 7, 7, swig_obj)) SWIG_fail;
7434 {
7435 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7436 if ( tmp1 == NULL )
7437 return NULL;
7438 Alen = PyArray_DIMS( tmp1 )[0];
7439 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7440 }
7441 {
7442 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
7443 if ( tmp2 == NULL )
7444 return NULL;
7445 if ( PyArray_DIMS( tmp2 )[0] != Alen )
7446 {
7447 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7448 return NULL;
7449 }
7450 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7451 }
7452 {
7453 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
7454 if ( tmp3 == NULL )
7455 return NULL;
7456 if ( PyArray_DIMS( tmp3 )[0] != Alen )
7457 {
7458 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7459 return NULL;
7460 }
7461 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7462 arg4 = PyArray_DIMS( tmp3 )[0];
7463 }
7464 {
7465 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
7466 if ( tmp5 == NULL )
7467 return NULL;
7468 Xlen = PyArray_DIMS( tmp5 )[0];
7469 arg6 = Xlen;
7470 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7471 }
7472 {
7473 int i, size;
7474 npy_intp dims[2];
7475 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
7476 if ( tmp7 == NULL )
7477 return NULL;
7478 Ylen = PyArray_DIMS( tmp7 )[0];
7479 arg8 = Ylen;
7480 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7481 // Make created 2D array7 have dimensions from prior ArrayX in the argument
7482 // list and this ArrayY.
7483 dims[0] = Xlen;
7484 dims[1] = Ylen;
7485 array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
7486 if ( !array7 )
7487 return NULL;
7488 size = Ylen;
7489 arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
7490 for ( i = 0; i < Xlen; i++ )
7491 arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7492 }
7493 ecode10 = SWIG_AsVal_int(swig_obj[5], &val10);
7494 if (!SWIG_IsOK(ecode10)) {
7495 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7496 }
7497 arg10 = (PLINT)(val10);
7498 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
7499 if (!SWIG_IsOK(ecode11)) {
7500 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7501 }
7502 arg11 = (PLFLT)(val11);
7503 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7504 resultobj = SWIG_Py_Void();
7505 {
7506 resultobj = SWIG_Python_AppendOutput(resultobj, array7);
7507 }
7508 {
7509 Py_CLEAR( tmp1 );
7510 }
7511 {
7512 Py_CLEAR( tmp2 );
7513 }
7514 {
7515 Py_CLEAR( tmp3 );
7516 }
7517 {
7518 Py_CLEAR( tmp5 );
7519 }
7520 {
7521 Py_CLEAR( tmp7 );
7522 free( arg9 );
7523 }
7524 return resultobj;
7525fail:
7526 {
7527 Py_CLEAR( tmp1 );
7528 }
7529 {
7530 Py_CLEAR( tmp2 );
7531 }
7532 {
7533 Py_CLEAR( tmp3 );
7534 }
7535 {
7536 Py_CLEAR( tmp5 );
7537 }
7538 {
7539 Py_CLEAR( tmp7 );
7540 free( arg9 );
7541 }
7542 return NULL;
7543}
7544
7545
7546SWIGINTERN PyObject *_wrap_plgspa(PyObject *self, PyObject *args) {
7547 PyObject *resultobj = 0;
7548 PLFLT *arg1 = (PLFLT *) 0 ;
7549 PLFLT *arg2 = (PLFLT *) 0 ;
7550 PLFLT *arg3 = (PLFLT *) 0 ;
7551 PLFLT *arg4 = (PLFLT *) 0 ;
7552 PLFLT temp1 ;
7553 int res1 = SWIG_TMPOBJ ;
7554 PLFLT temp2 ;
7555 int res2 = SWIG_TMPOBJ ;
7556 PLFLT temp3 ;
7557 int res3 = SWIG_TMPOBJ ;
7558 PLFLT temp4 ;
7559 int res4 = SWIG_TMPOBJ ;
7560
7561 arg1 = &temp1;
7562 arg2 = &temp2;
7563 arg3 = &temp3;
7564 arg4 = &temp4;
7565 (void)self;
7566 if (!SWIG_Python_UnpackTuple(args, "plgspa", 0, 0, 0)) SWIG_fail;
7567 plgspa(arg1,arg2,arg3,arg4);
7568 resultobj = SWIG_Py_Void();
7569 if (SWIG_IsTmpObj(res1)) {
7570 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7571 } else {
7572 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7573 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7574 }
7575 if (SWIG_IsTmpObj(res2)) {
7576 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7577 } else {
7578 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7579 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7580 }
7581 if (SWIG_IsTmpObj(res3)) {
7582 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7583 } else {
7584 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7585 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7586 }
7587 if (SWIG_IsTmpObj(res4)) {
7588 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7589 } else {
7590 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7591 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7592 }
7593 return resultobj;
7594fail:
7595 return NULL;
7596}
7597
7598
7599SWIGINTERN PyObject *_wrap_plgstrm(PyObject *self, PyObject *args) {
7600 PyObject *resultobj = 0;
7601 PLINT *arg1 = (PLINT *) 0 ;
7602 PLINT temp1 ;
7603 int res1 = SWIG_TMPOBJ ;
7604
7605 arg1 = &temp1;
7606 (void)self;
7607 if (!SWIG_Python_UnpackTuple(args, "plgstrm", 0, 0, 0)) SWIG_fail;
7608 plgstrm(arg1);
7609 resultobj = SWIG_Py_Void();
7610 if (SWIG_IsTmpObj(res1)) {
7611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7612 } else {
7613 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7615 }
7616 return resultobj;
7617fail:
7618 return NULL;
7619}
7620
7621
7622SWIGINTERN PyObject *_wrap_plgver(PyObject *self, PyObject *args) {
7623 PyObject *resultobj = 0;
7624 char *arg1 = (char *) 0 ;
7625 char buff1[1000] ;
7626
7627 {
7628 arg1 = buff1;
7629 }
7630 (void)self;
7631 if (!SWIG_Python_UnpackTuple(args, "plgver", 0, 0, 0)) SWIG_fail;
7632 plgver(arg1);
7633 resultobj = SWIG_Py_Void();
7634 {
7635 PyObject *o = PyString_FromString( arg1 );
7636 resultobj = SWIG_Python_AppendOutput(resultobj, o);
7637 }
7638 return resultobj;
7639fail:
7640 return NULL;
7641}
7642
7643
7644SWIGINTERN PyObject *_wrap_plgvpd(PyObject *self, PyObject *args) {
7645 PyObject *resultobj = 0;
7646 PLFLT *arg1 = (PLFLT *) 0 ;
7647 PLFLT *arg2 = (PLFLT *) 0 ;
7648 PLFLT *arg3 = (PLFLT *) 0 ;
7649 PLFLT *arg4 = (PLFLT *) 0 ;
7650 PLFLT temp1 ;
7651 int res1 = SWIG_TMPOBJ ;
7652 PLFLT temp2 ;
7653 int res2 = SWIG_TMPOBJ ;
7654 PLFLT temp3 ;
7655 int res3 = SWIG_TMPOBJ ;
7656 PLFLT temp4 ;
7657 int res4 = SWIG_TMPOBJ ;
7658
7659 arg1 = &temp1;
7660 arg2 = &temp2;
7661 arg3 = &temp3;
7662 arg4 = &temp4;
7663 (void)self;
7664 if (!SWIG_Python_UnpackTuple(args, "plgvpd", 0, 0, 0)) SWIG_fail;
7665 plgvpd(arg1,arg2,arg3,arg4);
7666 resultobj = SWIG_Py_Void();
7667 if (SWIG_IsTmpObj(res1)) {
7668 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7669 } else {
7670 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7671 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7672 }
7673 if (SWIG_IsTmpObj(res2)) {
7674 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7675 } else {
7676 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7677 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7678 }
7679 if (SWIG_IsTmpObj(res3)) {
7680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7681 } else {
7682 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7684 }
7685 if (SWIG_IsTmpObj(res4)) {
7686 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7687 } else {
7688 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7690 }
7691 return resultobj;
7692fail:
7693 return NULL;
7694}
7695
7696
7697SWIGINTERN PyObject *_wrap_plgvpw(PyObject *self, PyObject *args) {
7698 PyObject *resultobj = 0;
7699 PLFLT *arg1 = (PLFLT *) 0 ;
7700 PLFLT *arg2 = (PLFLT *) 0 ;
7701 PLFLT *arg3 = (PLFLT *) 0 ;
7702 PLFLT *arg4 = (PLFLT *) 0 ;
7703 PLFLT temp1 ;
7704 int res1 = SWIG_TMPOBJ ;
7705 PLFLT temp2 ;
7706 int res2 = SWIG_TMPOBJ ;
7707 PLFLT temp3 ;
7708 int res3 = SWIG_TMPOBJ ;
7709 PLFLT temp4 ;
7710 int res4 = SWIG_TMPOBJ ;
7711
7712 arg1 = &temp1;
7713 arg2 = &temp2;
7714 arg3 = &temp3;
7715 arg4 = &temp4;
7716 (void)self;
7717 if (!SWIG_Python_UnpackTuple(args, "plgvpw", 0, 0, 0)) SWIG_fail;
7718 plgvpw(arg1,arg2,arg3,arg4);
7719 resultobj = SWIG_Py_Void();
7720 if (SWIG_IsTmpObj(res1)) {
7721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7722 } else {
7723 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7725 }
7726 if (SWIG_IsTmpObj(res2)) {
7727 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7728 } else {
7729 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7731 }
7732 if (SWIG_IsTmpObj(res3)) {
7733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7734 } else {
7735 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7737 }
7738 if (SWIG_IsTmpObj(res4)) {
7739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7740 } else {
7741 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7743 }
7744 return resultobj;
7745fail:
7746 return NULL;
7747}
7748
7749
7750SWIGINTERN PyObject *_wrap_plgxax(PyObject *self, PyObject *args) {
7751 PyObject *resultobj = 0;
7752 PLINT *arg1 = (PLINT *) 0 ;
7753 PLINT *arg2 = (PLINT *) 0 ;
7754 PLINT temp1 ;
7755 int res1 = SWIG_TMPOBJ ;
7756 PLINT temp2 ;
7757 int res2 = SWIG_TMPOBJ ;
7758
7759 arg1 = &temp1;
7760 arg2 = &temp2;
7761 (void)self;
7762 if (!SWIG_Python_UnpackTuple(args, "plgxax", 0, 0, 0)) SWIG_fail;
7763 plgxax(arg1,arg2);
7764 resultobj = SWIG_Py_Void();
7765 if (SWIG_IsTmpObj(res1)) {
7766 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7767 } else {
7768 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7770 }
7771 if (SWIG_IsTmpObj(res2)) {
7772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7773 } else {
7774 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7776 }
7777 return resultobj;
7778fail:
7779 return NULL;
7780}
7781
7782
7783SWIGINTERN PyObject *_wrap_plgyax(PyObject *self, PyObject *args) {
7784 PyObject *resultobj = 0;
7785 PLINT *arg1 = (PLINT *) 0 ;
7786 PLINT *arg2 = (PLINT *) 0 ;
7787 PLINT temp1 ;
7788 int res1 = SWIG_TMPOBJ ;
7789 PLINT temp2 ;
7790 int res2 = SWIG_TMPOBJ ;
7791
7792 arg1 = &temp1;
7793 arg2 = &temp2;
7794 (void)self;
7795 if (!SWIG_Python_UnpackTuple(args, "plgyax", 0, 0, 0)) SWIG_fail;
7796 plgyax(arg1,arg2);
7797 resultobj = SWIG_Py_Void();
7798 if (SWIG_IsTmpObj(res1)) {
7799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7800 } else {
7801 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7803 }
7804 if (SWIG_IsTmpObj(res2)) {
7805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7806 } else {
7807 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7809 }
7810 return resultobj;
7811fail:
7812 return NULL;
7813}
7814
7815
7816SWIGINTERN PyObject *_wrap_plgzax(PyObject *self, PyObject *args) {
7817 PyObject *resultobj = 0;
7818 PLINT *arg1 = (PLINT *) 0 ;
7819 PLINT *arg2 = (PLINT *) 0 ;
7820 PLINT temp1 ;
7821 int res1 = SWIG_TMPOBJ ;
7822 PLINT temp2 ;
7823 int res2 = SWIG_TMPOBJ ;
7824
7825 arg1 = &temp1;
7826 arg2 = &temp2;
7827 (void)self;
7828 if (!SWIG_Python_UnpackTuple(args, "plgzax", 0, 0, 0)) SWIG_fail;
7829 plgzax(arg1,arg2);
7830 resultobj = SWIG_Py_Void();
7831 if (SWIG_IsTmpObj(res1)) {
7832 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7833 } else {
7834 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7835 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7836 }
7837 if (SWIG_IsTmpObj(res2)) {
7838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7839 } else {
7840 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7841 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7842 }
7843 return resultobj;
7844fail:
7845 return NULL;
7846}
7847
7848
7849SWIGINTERN PyObject *_wrap_plhist(PyObject *self, PyObject *args) {
7850 PyObject *resultobj = 0;
7851 PLINT arg1 ;
7852 PLFLT *arg2 = (PLFLT *) 0 ;
7853 PLFLT arg3 ;
7854 PLFLT arg4 ;
7855 PLINT arg5 ;
7856 PLINT arg6 ;
7857 PyArrayObject *tmp1 = NULL ;
7858 double val3 ;
7859 int ecode3 = 0 ;
7860 double val4 ;
7861 int ecode4 = 0 ;
7862 int val5 ;
7863 int ecode5 = 0 ;
7864 int val6 ;
7865 int ecode6 = 0 ;
7866 PyObject *swig_obj[5] ;
7867
7868 (void)self;
7869 if (!SWIG_Python_UnpackTuple(args, "plhist", 5, 5, swig_obj)) SWIG_fail;
7870 {
7871 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7872 if ( tmp1 == NULL )
7873 return NULL;
7874 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7875 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7876 }
7877 ecode3 = SWIG_AsVal_double(swig_obj[1], &val3);
7878 if (!SWIG_IsOK(ecode3)) {
7879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7880 }
7881 arg3 = (PLFLT)(val3);
7882 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
7883 if (!SWIG_IsOK(ecode4)) {
7884 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7885 }
7886 arg4 = (PLFLT)(val4);
7887 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
7888 if (!SWIG_IsOK(ecode5)) {
7889 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7890 }
7891 arg5 = (PLINT)(val5);
7892 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
7893 if (!SWIG_IsOK(ecode6)) {
7894 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7895 }
7896 arg6 = (PLINT)(val6);
7897 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7898 resultobj = SWIG_Py_Void();
7899 {
7900 Py_CLEAR( tmp1 );
7901 }
7902 return resultobj;
7903fail:
7904 {
7905 Py_CLEAR( tmp1 );
7906 }
7907 return NULL;
7908}
7909
7910
7911SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *self, PyObject *args) {
7912 PyObject *resultobj = 0;
7913 PLFLT arg1 ;
7914 PLFLT arg2 ;
7915 PLFLT arg3 ;
7916 PLFLT *arg4 = (PLFLT *) 0 ;
7917 PLFLT *arg5 = (PLFLT *) 0 ;
7918 PLFLT *arg6 = (PLFLT *) 0 ;
7919 double val1 ;
7920 int ecode1 = 0 ;
7921 double val2 ;
7922 int ecode2 = 0 ;
7923 double val3 ;
7924 int ecode3 = 0 ;
7925 PLFLT temp4 ;
7926 int res4 = SWIG_TMPOBJ ;
7927 PLFLT temp5 ;
7928 int res5 = SWIG_TMPOBJ ;
7929 PLFLT temp6 ;
7930 int res6 = SWIG_TMPOBJ ;
7931 PyObject *swig_obj[3] ;
7932
7933 arg4 = &temp4;
7934 arg5 = &temp5;
7935 arg6 = &temp6;
7936 (void)self;
7937 if (!SWIG_Python_UnpackTuple(args, "plhlsrgb", 3, 3, swig_obj)) SWIG_fail;
7938 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7939 if (!SWIG_IsOK(ecode1)) {
7940 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7941 }
7942 arg1 = (PLFLT)(val1);
7943 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7944 if (!SWIG_IsOK(ecode2)) {
7945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7946 }
7947 arg2 = (PLFLT)(val2);
7948 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7949 if (!SWIG_IsOK(ecode3)) {
7950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7951 }
7952 arg3 = (PLFLT)(val3);
7953 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7954 resultobj = SWIG_Py_Void();
7955 if (SWIG_IsTmpObj(res4)) {
7956 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7957 } else {
7958 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7959 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7960 }
7961 if (SWIG_IsTmpObj(res5)) {
7962 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7963 } else {
7964 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7965 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7966 }
7967 if (SWIG_IsTmpObj(res6)) {
7968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7969 } else {
7970 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7972 }
7973 return resultobj;
7974fail:
7975 return NULL;
7976}
7977
7978
7979SWIGINTERN PyObject *_wrap_plinit(PyObject *self, PyObject *args) {
7980 PyObject *resultobj = 0;
7981
7982 (void)self;
7983 if (!SWIG_Python_UnpackTuple(args, "plinit", 0, 0, 0)) SWIG_fail;
7984 plinit();
7985 resultobj = SWIG_Py_Void();
7986 return resultobj;
7987fail:
7988 return NULL;
7989}
7990
7991
7992SWIGINTERN PyObject *_wrap_pljoin(PyObject *self, PyObject *args) {
7993 PyObject *resultobj = 0;
7994 PLFLT arg1 ;
7995 PLFLT arg2 ;
7996 PLFLT arg3 ;
7997 PLFLT arg4 ;
7998 double val1 ;
7999 int ecode1 = 0 ;
8000 double val2 ;
8001 int ecode2 = 0 ;
8002 double val3 ;
8003 int ecode3 = 0 ;
8004 double val4 ;
8005 int ecode4 = 0 ;
8006 PyObject *swig_obj[4] ;
8007
8008 (void)self;
8009 if (!SWIG_Python_UnpackTuple(args, "pljoin", 4, 4, swig_obj)) SWIG_fail;
8010 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8011 if (!SWIG_IsOK(ecode1)) {
8012 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
8013 }
8014 arg1 = (PLFLT)(val1);
8015 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8016 if (!SWIG_IsOK(ecode2)) {
8017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
8018 }
8019 arg2 = (PLFLT)(val2);
8020 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8021 if (!SWIG_IsOK(ecode3)) {
8022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
8023 }
8024 arg3 = (PLFLT)(val3);
8025 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8026 if (!SWIG_IsOK(ecode4)) {
8027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
8028 }
8029 arg4 = (PLFLT)(val4);
8030 pljoin(arg1,arg2,arg3,arg4);
8031 resultobj = SWIG_Py_Void();
8032 return resultobj;
8033fail:
8034 return NULL;
8035}
8036
8037
8038SWIGINTERN PyObject *_wrap_pllab(PyObject *self, PyObject *args) {
8039 PyObject *resultobj = 0;
8040 char *arg1 = (char *) 0 ;
8041 char *arg2 = (char *) 0 ;
8042 char *arg3 = (char *) 0 ;
8043 int res1 ;
8044 char *buf1 = 0 ;
8045 int alloc1 = 0 ;
8046 int res2 ;
8047 char *buf2 = 0 ;
8048 int alloc2 = 0 ;
8049 int res3 ;
8050 char *buf3 = 0 ;
8051 int alloc3 = 0 ;
8052 PyObject *swig_obj[3] ;
8053
8054 (void)self;
8055 if (!SWIG_Python_UnpackTuple(args, "pllab", 3, 3, swig_obj)) SWIG_fail;
8056 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8057 if (!SWIG_IsOK(res1)) {
8058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
8059 }
8060 arg1 = (char *)(buf1);
8061 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
8062 if (!SWIG_IsOK(res2)) {
8063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
8064 }
8065 arg2 = (char *)(buf2);
8066 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
8067 if (!SWIG_IsOK(res3)) {
8068 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
8069 }
8070 arg3 = (char *)(buf3);
8071 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
8072 resultobj = SWIG_Py_Void();
8073 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8074 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8075 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8076 return resultobj;
8077fail:
8078 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8079 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8080 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8081 return NULL;
8082}
8083
8084
8085SWIGINTERN PyObject *_wrap_pllegend(PyObject *self, PyObject *args) {
8086 PyObject *resultobj = 0;
8087 PLFLT *arg1 = (PLFLT *) 0 ;
8088 PLFLT *arg2 = (PLFLT *) 0 ;
8089 PLINT arg3 ;
8090 PLINT arg4 ;
8091 PLFLT arg5 ;
8092 PLFLT arg6 ;
8093 PLFLT arg7 ;
8094 PLINT arg8 ;
8095 PLINT arg9 ;
8096 PLINT arg10 ;
8097 PLINT arg11 ;
8098 PLINT arg12 ;
8099 PLINT arg13 ;
8100 PLINT *arg14 = (PLINT *) 0 ;
8101 PLFLT arg15 ;
8102 PLFLT arg16 ;
8103 PLFLT arg17 ;
8104 PLFLT arg18 ;
8105 PLINT *arg19 = (PLINT *) 0 ;
8106 char **arg20 = (char **) 0 ;
8107 PLINT *arg21 = (PLINT *) 0 ;
8108 PLINT *arg22 = (PLINT *) 0 ;
8109 PLFLT *arg23 = (PLFLT *) 0 ;
8110 PLFLT *arg24 = (PLFLT *) 0 ;
8111 PLINT *arg25 = (PLINT *) 0 ;
8112 PLINT *arg26 = (PLINT *) 0 ;
8113 PLFLT *arg27 = (PLFLT *) 0 ;
8114 PLINT *arg28 = (PLINT *) 0 ;
8115 PLFLT *arg29 = (PLFLT *) 0 ;
8116 PLINT *arg30 = (PLINT *) 0 ;
8117 char **arg31 = (char **) 0 ;
8118 PLFLT temp1 ;
8119 int res1 = SWIG_TMPOBJ ;
8120 PLFLT temp2 ;
8121 int res2 = SWIG_TMPOBJ ;
8122 int val3 ;
8123 int ecode3 = 0 ;
8124 int val4 ;
8125 int ecode4 = 0 ;
8126 double val5 ;
8127 int ecode5 = 0 ;
8128 double val6 ;
8129 int ecode6 = 0 ;
8130 double val7 ;
8131 int ecode7 = 0 ;
8132 int val8 ;
8133 int ecode8 = 0 ;
8134 int val9 ;
8135 int ecode9 = 0 ;
8136 int val10 ;
8137 int ecode10 = 0 ;
8138 int val11 ;
8139 int ecode11 = 0 ;
8140 int val12 ;
8141 int ecode12 = 0 ;
8142 PyArrayObject *tmp13 = NULL ;
8143 double val15 ;
8144 int ecode15 = 0 ;
8145 double val16 ;
8146 int ecode16 = 0 ;
8147 double val17 ;
8148 int ecode17 = 0 ;
8149 double val18 ;
8150 int ecode18 = 0 ;
8151 PyArrayObject *tmp19 = NULL ;
8152 PyArrayObject *tmp20 = NULL ;
8153 PyArrayObject *tmp21 = NULL ;
8154 PyArrayObject *tmp22 = NULL ;
8155 PyArrayObject *tmp23 = NULL ;
8156 PyArrayObject *tmp24 = NULL ;
8157 PyArrayObject *tmp25 = NULL ;
8158 PyArrayObject *tmp26 = NULL ;
8159 PyArrayObject *tmp27 = NULL ;
8160 PyArrayObject *tmp28 = NULL ;
8161 PyArrayObject *tmp29 = NULL ;
8162 PyArrayObject *tmp30 = NULL ;
8163 PyArrayObject *tmp31 = NULL ;
8164 PyObject *swig_obj[28] ;
8165
8166 arg1 = &temp1;
8167 arg2 = &temp2;
8168 (void)self;
8169 if (!SWIG_Python_UnpackTuple(args, "pllegend", 28, 28, swig_obj)) SWIG_fail;
8170 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8171 if (!SWIG_IsOK(ecode3)) {
8172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
8173 }
8174 arg3 = (PLINT)(val3);
8175 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8176 if (!SWIG_IsOK(ecode4)) {
8177 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
8178 }
8179 arg4 = (PLINT)(val4);
8180 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8181 if (!SWIG_IsOK(ecode5)) {
8182 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
8183 }
8184 arg5 = (PLFLT)(val5);
8185 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8186 if (!SWIG_IsOK(ecode6)) {
8187 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
8188 }
8189 arg6 = (PLFLT)(val6);
8190 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8191 if (!SWIG_IsOK(ecode7)) {
8192 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
8193 }
8194 arg7 = (PLFLT)(val7);
8195 ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
8196 if (!SWIG_IsOK(ecode8)) {
8197 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
8198 }
8199 arg8 = (PLINT)(val8);
8200 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8201 if (!SWIG_IsOK(ecode9)) {
8202 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
8203 }
8204 arg9 = (PLINT)(val9);
8205 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8206 if (!SWIG_IsOK(ecode10)) {
8207 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
8208 }
8209 arg10 = (PLINT)(val10);
8210 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8211 if (!SWIG_IsOK(ecode11)) {
8212 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
8213 }
8214 arg11 = (PLINT)(val11);
8215 ecode12 = SWIG_AsVal_int(swig_obj[9], &val12);
8216 if (!SWIG_IsOK(ecode12)) {
8217 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
8218 }
8219 arg12 = (PLINT)(val12);
8220 {
8221 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[10], NPY_PLINT, 1, 1 );
8222 if ( tmp13 == NULL )
8223 return NULL;
8224 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
8225 arg14 = (PLINT *) PyArray_DATA( tmp13 );
8226 }
8227 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
8228 if (!SWIG_IsOK(ecode15)) {
8229 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
8230 }
8231 arg15 = (PLFLT)(val15);
8232 ecode16 = SWIG_AsVal_double(swig_obj[12], &val16);
8233 if (!SWIG_IsOK(ecode16)) {
8234 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
8235 }
8236 arg16 = (PLFLT)(val16);
8237 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
8238 if (!SWIG_IsOK(ecode17)) {
8239 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
8240 }
8241 arg17 = (PLFLT)(val17);
8242 ecode18 = SWIG_AsVal_double(swig_obj[14], &val18);
8243 if (!SWIG_IsOK(ecode18)) {
8244 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
8245 }
8246 arg18 = (PLFLT)(val18);
8247 {
8248 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[15], NPY_PLINT, 1, 1 );
8249 if ( tmp19 == NULL )
8250 return NULL;
8251 if ( PyArray_DIMS( tmp19 )[0] != Alen )
8252 {
8253 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8254 return NULL;
8255 }
8256 arg19 = (PLINT *) PyArray_DATA( tmp19 );
8257 }
8258 {
8259 int i;
8260 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[16], NPY_STRING, 1, 1 );
8261 if ( tmp20 == NULL )
8262 return NULL;
8263 if ( PyArray_DIMS( tmp20 )[0] != Alen )
8264 {
8265 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8266 return NULL;
8267 }
8268 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8269 for ( i = 0; i < Alen; i++ )
8270 {
8271 arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8272 if ( arg20[i] == NULL )
8273 {
8274 free( arg20 );
8275 return NULL;
8276 }
8277 }
8278 }
8279 {
8280 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8281 if ( tmp21 == NULL )
8282 return NULL;
8283 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8284 {
8285 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8286 return NULL;
8287 }
8288 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8289 }
8290 {
8291 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8292 if ( tmp22 == NULL )
8293 return NULL;
8294 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8295 {
8296 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8297 return NULL;
8298 }
8299 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8300 }
8301 {
8302 if ( swig_obj[19] != Py_None )
8303 {
8304 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 1, 1 );
8305 if ( tmp23 == NULL )
8306 return NULL;
8307 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8308 {
8309 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8310 return NULL;
8311 }
8312 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8313 }
8314 else
8315 {
8316 arg23 = NULL;
8317 }
8318 }
8319 {
8320 if ( swig_obj[20] != Py_None )
8321 {
8322 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[20], NPY_PLFLT, 1, 1 );
8323 if ( tmp24 == NULL )
8324 return NULL;
8325 if ( PyArray_DIMS( tmp24 )[0] != Alen )
8326 {
8327 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8328 return NULL;
8329 }
8330 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8331 }
8332 else
8333 {
8334 arg24 = NULL;
8335 }
8336 }
8337 {
8338 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[21], NPY_PLINT, 1, 1 );
8339 if ( tmp25 == NULL )
8340 return NULL;
8341 if ( PyArray_DIMS( tmp25 )[0] != Alen )
8342 {
8343 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8344 return NULL;
8345 }
8346 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8347 }
8348 {
8349 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[22], NPY_PLINT, 1, 1 );
8350 if ( tmp26 == NULL )
8351 return NULL;
8352 if ( PyArray_DIMS( tmp26 )[0] != Alen )
8353 {
8354 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8355 return NULL;
8356 }
8357 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8358 }
8359 {
8360 if ( swig_obj[23] != Py_None )
8361 {
8362 tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[23], NPY_PLFLT, 1, 1 );
8363 if ( tmp27 == NULL )
8364 return NULL;
8365 if ( PyArray_DIMS( tmp27 )[0] != Alen )
8366 {
8367 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8368 return NULL;
8369 }
8370 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8371 }
8372 else
8373 {
8374 arg27 = NULL;
8375 }
8376 }
8377 {
8378 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[24], NPY_PLINT, 1, 1 );
8379 if ( tmp28 == NULL )
8380 return NULL;
8381 if ( PyArray_DIMS( tmp28 )[0] != Alen )
8382 {
8383 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8384 return NULL;
8385 }
8386 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8387 }
8388 {
8389 if ( swig_obj[25] != Py_None )
8390 {
8391 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[25], NPY_PLFLT, 1, 1 );
8392 if ( tmp29 == NULL )
8393 return NULL;
8394 if ( PyArray_DIMS( tmp29 )[0] != Alen )
8395 {
8396 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8397 return NULL;
8398 }
8399 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8400 }
8401 else
8402 {
8403 arg29 = NULL;
8404 }
8405 }
8406 {
8407 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[26], NPY_PLINT, 1, 1 );
8408 if ( tmp30 == NULL )
8409 return NULL;
8410 if ( PyArray_DIMS( tmp30 )[0] != Alen )
8411 {
8412 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8413 return NULL;
8414 }
8415 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8416 }
8417 {
8418 int i;
8419 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[27], NPY_STRING, 1, 1 );
8420 if ( tmp31 == NULL )
8421 return NULL;
8422 if ( PyArray_DIMS( tmp31 )[0] != Alen )
8423 {
8424 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8425 return NULL;
8426 }
8427 arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8428 for ( i = 0; i < Alen; i++ )
8429 {
8430 arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8431 if ( arg31[i] == NULL )
8432 {
8433 free( arg31 );
8434 return NULL;
8435 }
8436 }
8437 }
8438 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);
8439 resultobj = SWIG_Py_Void();
8440 if (SWIG_IsTmpObj(res1)) {
8441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8442 } else {
8443 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8445 }
8446 if (SWIG_IsTmpObj(res2)) {
8447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8448 } else {
8449 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8450 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8451 }
8452 {
8453 Py_CLEAR( tmp13 );
8454 }
8455 {
8456 Py_CLEAR( tmp19 );
8457 }
8458 {
8459 Py_CLEAR( tmp20 ); free( arg20 );
8460 }
8461 {
8462 Py_CLEAR( tmp21 );
8463 }
8464 {
8465 Py_CLEAR( tmp22 );
8466 }
8467 {
8468 Py_CLEAR( tmp23 );
8469 }
8470 {
8471 Py_CLEAR( tmp24 );
8472 }
8473 {
8474 Py_CLEAR( tmp25 );
8475 }
8476 {
8477 Py_CLEAR( tmp26 );
8478 }
8479 {
8480 Py_CLEAR( tmp27 );
8481 }
8482 {
8483 Py_CLEAR( tmp28 );
8484 }
8485 {
8486 Py_CLEAR( tmp29 );
8487 }
8488 {
8489 Py_CLEAR( tmp30 );
8490 }
8491 {
8492 Py_CLEAR( tmp31 ); free( arg31 );
8493 }
8494 return resultobj;
8495fail:
8496 {
8497 Py_CLEAR( tmp13 );
8498 }
8499 {
8500 Py_CLEAR( tmp19 );
8501 }
8502 {
8503 Py_CLEAR( tmp20 ); free( arg20 );
8504 }
8505 {
8506 Py_CLEAR( tmp21 );
8507 }
8508 {
8509 Py_CLEAR( tmp22 );
8510 }
8511 {
8512 Py_CLEAR( tmp23 );
8513 }
8514 {
8515 Py_CLEAR( tmp24 );
8516 }
8517 {
8518 Py_CLEAR( tmp25 );
8519 }
8520 {
8521 Py_CLEAR( tmp26 );
8522 }
8523 {
8524 Py_CLEAR( tmp27 );
8525 }
8526 {
8527 Py_CLEAR( tmp28 );
8528 }
8529 {
8530 Py_CLEAR( tmp29 );
8531 }
8532 {
8533 Py_CLEAR( tmp30 );
8534 }
8535 {
8536 Py_CLEAR( tmp31 ); free( arg31 );
8537 }
8538 return NULL;
8539}
8540
8541
8542SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *self, PyObject *args) {
8543 PyObject *resultobj = 0;
8544 PLFLT *arg1 = (PLFLT *) 0 ;
8545 PLFLT *arg2 = (PLFLT *) 0 ;
8546 PLINT arg3 ;
8547 PLINT arg4 ;
8548 PLFLT arg5 ;
8549 PLFLT arg6 ;
8550 PLFLT arg7 ;
8551 PLFLT arg8 ;
8552 PLINT arg9 ;
8553 PLINT arg10 ;
8554 PLINT arg11 ;
8555 PLFLT arg12 ;
8556 PLFLT arg13 ;
8557 PLINT arg14 ;
8558 PLFLT arg15 ;
8559 PLINT arg16 ;
8560 PLINT *arg17 = (PLINT *) 0 ;
8561 char **arg18 = (char **) 0 ;
8562 PLINT arg19 ;
8563 char **arg20 = (char **) 0 ;
8564 PLFLT *arg21 = (PLFLT *) 0 ;
8565 PLINT *arg22 = (PLINT *) 0 ;
8566 PLINT *arg23 = (PLINT *) 0 ;
8567 PLFLT **arg24 = (PLFLT **) 0 ;
8568 PLFLT temp1 ;
8569 int res1 = SWIG_TMPOBJ ;
8570 PLFLT temp2 ;
8571 int res2 = SWIG_TMPOBJ ;
8572 int val3 ;
8573 int ecode3 = 0 ;
8574 int val4 ;
8575 int ecode4 = 0 ;
8576 double val5 ;
8577 int ecode5 = 0 ;
8578 double val6 ;
8579 int ecode6 = 0 ;
8580 double val7 ;
8581 int ecode7 = 0 ;
8582 double val8 ;
8583 int ecode8 = 0 ;
8584 int val9 ;
8585 int ecode9 = 0 ;
8586 int val10 ;
8587 int ecode10 = 0 ;
8588 int val11 ;
8589 int ecode11 = 0 ;
8590 double val12 ;
8591 int ecode12 = 0 ;
8592 double val13 ;
8593 int ecode13 = 0 ;
8594 int val14 ;
8595 int ecode14 = 0 ;
8596 double val15 ;
8597 int ecode15 = 0 ;
8598 PyArrayObject *tmp16 = NULL ;
8599 PyArrayObject *tmp18 = NULL ;
8600 PyArrayObject *tmp19 = NULL ;
8601 PyArrayObject *tmp21 = NULL ;
8602 PyArrayObject *tmp22 = NULL ;
8603 PyArrayObject *tmp23 = NULL ;
8604 PyArrayObject *tmp24 = NULL ;
8605 PyObject *swig_obj[20] ;
8606
8607 arg1 = &temp1;
8608 arg2 = &temp2;
8609 (void)self;
8610 if (!SWIG_Python_UnpackTuple(args, "plcolorbar", 20, 20, swig_obj)) SWIG_fail;
8611 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8612 if (!SWIG_IsOK(ecode3)) {
8613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8614 }
8615 arg3 = (PLINT)(val3);
8616 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8617 if (!SWIG_IsOK(ecode4)) {
8618 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8619 }
8620 arg4 = (PLINT)(val4);
8621 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8622 if (!SWIG_IsOK(ecode5)) {
8623 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8624 }
8625 arg5 = (PLFLT)(val5);
8626 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8627 if (!SWIG_IsOK(ecode6)) {
8628 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8629 }
8630 arg6 = (PLFLT)(val6);
8631 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8632 if (!SWIG_IsOK(ecode7)) {
8633 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8634 }
8635 arg7 = (PLFLT)(val7);
8636 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
8637 if (!SWIG_IsOK(ecode8)) {
8638 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8639 }
8640 arg8 = (PLFLT)(val8);
8641 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8642 if (!SWIG_IsOK(ecode9)) {
8643 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8644 }
8645 arg9 = (PLINT)(val9);
8646 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8647 if (!SWIG_IsOK(ecode10)) {
8648 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8649 }
8650 arg10 = (PLINT)(val10);
8651 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8652 if (!SWIG_IsOK(ecode11)) {
8653 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8654 }
8655 arg11 = (PLINT)(val11);
8656 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
8657 if (!SWIG_IsOK(ecode12)) {
8658 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8659 }
8660 arg12 = (PLFLT)(val12);
8661 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
8662 if (!SWIG_IsOK(ecode13)) {
8663 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8664 }
8665 arg13 = (PLFLT)(val13);
8666 ecode14 = SWIG_AsVal_int(swig_obj[11], &val14);
8667 if (!SWIG_IsOK(ecode14)) {
8668 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8669 }
8670 arg14 = (PLINT)(val14);
8671 ecode15 = SWIG_AsVal_double(swig_obj[12], &val15);
8672 if (!SWIG_IsOK(ecode15)) {
8673 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8674 }
8675 arg15 = (PLFLT)(val15);
8676 {
8677 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
8678 if ( tmp16 == NULL )
8679 return NULL;
8680 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8681 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8682 }
8683 {
8684 int i;
8685 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[14], NPY_STRING, 1, 1 );
8686 if ( tmp18 == NULL )
8687 return NULL;
8688 if ( PyArray_DIMS( tmp18 )[0] != Alen )
8689 {
8690 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8691 return NULL;
8692 }
8693 arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8694 for ( i = 0; i < Alen; i++ )
8695 {
8696 arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8697 if ( arg18[i] == NULL )
8698 {
8699 free( arg18 );
8700 return NULL;
8701 }
8702 }
8703 }
8704 {
8705 int i;
8706 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[15], NPY_STRING, 1, 1 );
8707 if ( tmp19 == NULL )
8708 return NULL;
8709 Alen = PyArray_DIMS( tmp19 )[0];
8710 arg19 = Alen;
8711 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8712 for ( i = 0; i < Alen; i++ )
8713 {
8714 arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8715 if ( arg20[i] == NULL )
8716 {
8717 free( arg20 );
8718 return NULL;
8719 }
8720 }
8721 }
8722 {
8723 tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[16], NPY_PLFLT, 1, 1 );
8724 if ( tmp21 == NULL )
8725 return NULL;
8726 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8727 {
8728 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8729 return NULL;
8730 }
8731 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8732 }
8733 {
8734 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8735 if ( tmp22 == NULL )
8736 return NULL;
8737 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8738 {
8739 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8740 return NULL;
8741 }
8742 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8743 }
8744 {
8745 int i;
8746 tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8747 if ( tmp23 == NULL )
8748 return NULL;
8749 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8750 {
8751 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8752 return NULL;
8753 }
8754 Xlen = PyArray_DIMS( tmp23 )[0];
8755 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8756 Ylen = -1;
8757 for ( i = 0; i < Xlen; i++ )
8758 if ( arg23[i] > Ylen )
8759 Ylen = arg23[i];
8760 }
8761 {
8762 int i, size;
8763 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 2, 2 );
8764 if ( tmp24 == NULL )
8765 return NULL;
8766 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8767 {
8768 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8769 return NULL;
8770 }
8771 size = Ylen;
8772 arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8773 for ( i = 0; i < Xlen; i++ )
8774 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8775 }
8776 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);
8777 resultobj = SWIG_Py_Void();
8778 if (SWIG_IsTmpObj(res1)) {
8779 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8780 } else {
8781 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8782 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8783 }
8784 if (SWIG_IsTmpObj(res2)) {
8785 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8786 } else {
8787 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8788 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8789 }
8790 {
8791 Py_CLEAR( tmp16 );
8792 }
8793 {
8794 Py_CLEAR( tmp18 ); free( arg18 );
8795 }
8796 {
8797 Py_CLEAR( tmp19 ); free( arg20 );
8798 }
8799 {
8800 Py_CLEAR( tmp21 );
8801 }
8802 {
8803 Py_CLEAR( tmp22 );
8804 }
8805 {
8806 Py_CLEAR( tmp23 );
8807 }
8808 {
8809 Py_CLEAR( tmp24 );
8810 free( arg24 );
8811 }
8812 return resultobj;
8813fail:
8814 {
8815 Py_CLEAR( tmp16 );
8816 }
8817 {
8818 Py_CLEAR( tmp18 ); free( arg18 );
8819 }
8820 {
8821 Py_CLEAR( tmp19 ); free( arg20 );
8822 }
8823 {
8824 Py_CLEAR( tmp21 );
8825 }
8826 {
8827 Py_CLEAR( tmp22 );
8828 }
8829 {
8830 Py_CLEAR( tmp23 );
8831 }
8832 {
8833 Py_CLEAR( tmp24 );
8834 free( arg24 );
8835 }
8836 return NULL;
8837}
8838
8839
8840SWIGINTERN PyObject *_wrap_pllightsource(PyObject *self, PyObject *args) {
8841 PyObject *resultobj = 0;
8842 PLFLT arg1 ;
8843 PLFLT arg2 ;
8844 PLFLT arg3 ;
8845 double val1 ;
8846 int ecode1 = 0 ;
8847 double val2 ;
8848 int ecode2 = 0 ;
8849 double val3 ;
8850 int ecode3 = 0 ;
8851 PyObject *swig_obj[3] ;
8852
8853 (void)self;
8854 if (!SWIG_Python_UnpackTuple(args, "pllightsource", 3, 3, swig_obj)) SWIG_fail;
8855 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8856 if (!SWIG_IsOK(ecode1)) {
8857 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8858 }
8859 arg1 = (PLFLT)(val1);
8860 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8861 if (!SWIG_IsOK(ecode2)) {
8862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8863 }
8864 arg2 = (PLFLT)(val2);
8865 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8866 if (!SWIG_IsOK(ecode3)) {
8867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8868 }
8869 arg3 = (PLFLT)(val3);
8870 pllightsource(arg1,arg2,arg3);
8871 resultobj = SWIG_Py_Void();
8872 return resultobj;
8873fail:
8874 return NULL;
8875}
8876
8877
8878SWIGINTERN PyObject *_wrap_plline(PyObject *self, PyObject *args) {
8879 PyObject *resultobj = 0;
8880 PLINT arg1 ;
8881 PLFLT *arg2 = (PLFLT *) 0 ;
8882 PLFLT *arg3 = (PLFLT *) 0 ;
8883 PyArrayObject *tmp1 = NULL ;
8884 PyArrayObject *tmp3 = NULL ;
8885 PyObject *swig_obj[2] ;
8886
8887 (void)self;
8888 if (!SWIG_Python_UnpackTuple(args, "plline", 2, 2, swig_obj)) SWIG_fail;
8889 {
8890 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8891 if ( tmp1 == NULL )
8892 return NULL;
8893 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8894 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8895 }
8896 {
8897 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8898 if ( tmp3 == NULL )
8899 return NULL;
8900 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8901 {
8902 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8903 return NULL;
8904 }
8905 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8906 }
8907 plline(arg1,(double const *)arg2,(double const *)arg3);
8908 resultobj = SWIG_Py_Void();
8909 {
8910 Py_CLEAR( tmp1 );
8911 }
8912 {
8913 Py_CLEAR( tmp3 );
8914 }
8915 return resultobj;
8916fail:
8917 {
8918 Py_CLEAR( tmp1 );
8919 }
8920 {
8921 Py_CLEAR( tmp3 );
8922 }
8923 return NULL;
8924}
8925
8926
8927SWIGINTERN PyObject *_wrap_plline3(PyObject *self, PyObject *args) {
8928 PyObject *resultobj = 0;
8929 PLINT arg1 ;
8930 PLFLT *arg2 = (PLFLT *) 0 ;
8931 PLFLT *arg3 = (PLFLT *) 0 ;
8932 PLFLT *arg4 = (PLFLT *) 0 ;
8933 PyArrayObject *tmp1 = NULL ;
8934 PyArrayObject *tmp3 = NULL ;
8935 PyArrayObject *tmp4 = NULL ;
8936 PyObject *swig_obj[3] ;
8937
8938 (void)self;
8939 if (!SWIG_Python_UnpackTuple(args, "plline3", 3, 3, swig_obj)) SWIG_fail;
8940 {
8941 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8942 if ( tmp1 == NULL )
8943 return NULL;
8944 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8945 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8946 }
8947 {
8948 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8949 if ( tmp3 == NULL )
8950 return NULL;
8951 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8952 {
8953 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8954 return NULL;
8955 }
8956 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8957 }
8958 {
8959 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
8960 if ( tmp4 == NULL )
8961 return NULL;
8962 if ( PyArray_DIMS( tmp4 )[0] != Alen )
8963 {
8964 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8965 return NULL;
8966 }
8967 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8968 }
8969 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8970 resultobj = SWIG_Py_Void();
8971 {
8972 Py_CLEAR( tmp1 );
8973 }
8974 {
8975 Py_CLEAR( tmp3 );
8976 }
8977 {
8978 Py_CLEAR( tmp4 );
8979 }
8980 return resultobj;
8981fail:
8982 {
8983 Py_CLEAR( tmp1 );
8984 }
8985 {
8986 Py_CLEAR( tmp3 );
8987 }
8988 {
8989 Py_CLEAR( tmp4 );
8990 }
8991 return NULL;
8992}
8993
8994
8995SWIGINTERN PyObject *_wrap_pllsty(PyObject *self, PyObject *args) {
8996 PyObject *resultobj = 0;
8997 PLINT arg1 ;
8998 int val1 ;
8999 int ecode1 = 0 ;
9000 PyObject *swig_obj[1] ;
9001
9002 (void)self;
9003 if (!args) SWIG_fail;
9004 swig_obj[0] = args;
9005 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9006 if (!SWIG_IsOK(ecode1)) {
9007 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
9008 }
9009 arg1 = (PLINT)(val1);
9010 pllsty(arg1);
9011 resultobj = SWIG_Py_Void();
9012 return resultobj;
9013fail:
9014 return NULL;
9015}
9016
9017
9018SWIGINTERN PyObject *_wrap_plmesh(PyObject *self, PyObject *args) {
9019 PyObject *resultobj = 0;
9020 PLFLT *arg1 = (PLFLT *) 0 ;
9021 PLFLT *arg2 = (PLFLT *) 0 ;
9022 PLFLT **arg3 = (PLFLT **) 0 ;
9023 PLINT arg4 ;
9024 PLINT arg5 ;
9025 PLINT arg6 ;
9026 PyArrayObject *tmp1 = NULL ;
9027 PyArrayObject *tmp2 = NULL ;
9028 PyArrayObject *tmp3 = NULL ;
9029 int val6 ;
9030 int ecode6 = 0 ;
9031 PyObject *swig_obj[4] ;
9032
9033 (void)self;
9034 if (!SWIG_Python_UnpackTuple(args, "plmesh", 4, 4, swig_obj)) SWIG_fail;
9035 {
9036 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9037 if ( tmp1 == NULL )
9038 return NULL;
9039 Xlen = PyArray_DIMS( tmp1 )[0];
9040 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9041 }
9042 {
9043 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9044 if ( tmp2 == NULL )
9045 return NULL;
9046 Ylen = PyArray_DIMS( tmp2 )[0];
9047 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9048 }
9049 {
9050 int i, size;
9051 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9052 if ( tmp3 == NULL )
9053 return NULL;
9054 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9055 {
9056 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9057 return NULL;
9058 }
9059 arg4 = PyArray_DIMS( tmp3 )[0];
9060 arg5 = PyArray_DIMS( tmp3 )[1];
9061 size = arg5;
9062 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9063 for ( i = 0; i < arg4; i++ )
9064 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9065 }
9066 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9067 if (!SWIG_IsOK(ecode6)) {
9068 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
9069 }
9070 arg6 = (PLINT)(val6);
9071 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
9072 resultobj = SWIG_Py_Void();
9073 {
9074 Py_CLEAR( tmp1 );
9075 }
9076 {
9077 Py_CLEAR( tmp2 );
9078 }
9079 {
9080 Py_CLEAR( tmp3 );
9081 free( arg3 );
9082 }
9083 return resultobj;
9084fail:
9085 {
9086 Py_CLEAR( tmp1 );
9087 }
9088 {
9089 Py_CLEAR( tmp2 );
9090 }
9091 {
9092 Py_CLEAR( tmp3 );
9093 free( arg3 );
9094 }
9095 return NULL;
9096}
9097
9098
9099SWIGINTERN PyObject *_wrap_plmeshc(PyObject *self, PyObject *args) {
9100 PyObject *resultobj = 0;
9101 PLFLT *arg1 = (PLFLT *) 0 ;
9102 PLFLT *arg2 = (PLFLT *) 0 ;
9103 PLFLT **arg3 = (PLFLT **) 0 ;
9104 PLINT arg4 ;
9105 PLINT arg5 ;
9106 PLINT arg6 ;
9107 PLFLT *arg7 = (PLFLT *) 0 ;
9108 PLINT arg8 ;
9109 PyArrayObject *tmp1 = NULL ;
9110 PyArrayObject *tmp2 = NULL ;
9111 PyArrayObject *tmp3 = NULL ;
9112 int val6 ;
9113 int ecode6 = 0 ;
9114 PyArrayObject *tmp7 = NULL ;
9115 PyObject *swig_obj[5] ;
9116
9117 (void)self;
9118 if (!SWIG_Python_UnpackTuple(args, "plmeshc", 5, 5, swig_obj)) SWIG_fail;
9119 {
9120 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9121 if ( tmp1 == NULL )
9122 return NULL;
9123 Xlen = PyArray_DIMS( tmp1 )[0];
9124 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9125 }
9126 {
9127 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9128 if ( tmp2 == NULL )
9129 return NULL;
9130 Ylen = PyArray_DIMS( tmp2 )[0];
9131 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9132 }
9133 {
9134 int i, size;
9135 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9136 if ( tmp3 == NULL )
9137 return NULL;
9138 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9139 {
9140 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9141 return NULL;
9142 }
9143 arg4 = PyArray_DIMS( tmp3 )[0];
9144 arg5 = PyArray_DIMS( tmp3 )[1];
9145 size = arg5;
9146 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9147 for ( i = 0; i < arg4; i++ )
9148 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9149 }
9150 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9151 if (!SWIG_IsOK(ecode6)) {
9152 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9153 }
9154 arg6 = (PLINT)(val6);
9155 {
9156 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9157 if ( tmp7 == NULL )
9158 return NULL;
9159 arg8 = PyArray_DIMS( tmp7 )[0];
9160 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9161 }
9162 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9163 resultobj = SWIG_Py_Void();
9164 {
9165 Py_CLEAR( tmp1 );
9166 }
9167 {
9168 Py_CLEAR( tmp2 );
9169 }
9170 {
9171 Py_CLEAR( tmp3 );
9172 free( arg3 );
9173 }
9174 {
9175 Py_CLEAR( tmp7 );
9176 }
9177 return resultobj;
9178fail:
9179 {
9180 Py_CLEAR( tmp1 );
9181 }
9182 {
9183 Py_CLEAR( tmp2 );
9184 }
9185 {
9186 Py_CLEAR( tmp3 );
9187 free( arg3 );
9188 }
9189 {
9190 Py_CLEAR( tmp7 );
9191 }
9192 return NULL;
9193}
9194
9195
9196SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *self, PyObject *args) {
9197 PyObject *resultobj = 0;
9198 PLINT *arg1 = (PLINT *) 0 ;
9199 PLINT temp1 ;
9200 int res1 = SWIG_TMPOBJ ;
9201
9202 arg1 = &temp1;
9203 (void)self;
9204 if (!SWIG_Python_UnpackTuple(args, "plmkstrm", 0, 0, 0)) SWIG_fail;
9205 plmkstrm(arg1);
9206 resultobj = SWIG_Py_Void();
9207 if (SWIG_IsTmpObj(res1)) {
9208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
9209 } else {
9210 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9211 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
9212 }
9213 return resultobj;
9214fail:
9215 return NULL;
9216}
9217
9218
9219SWIGINTERN PyObject *_wrap_plmtex(PyObject *self, PyObject *args) {
9220 PyObject *resultobj = 0;
9221 char *arg1 = (char *) 0 ;
9222 PLFLT arg2 ;
9223 PLFLT arg3 ;
9224 PLFLT arg4 ;
9225 char *arg5 = (char *) 0 ;
9226 int res1 ;
9227 char *buf1 = 0 ;
9228 int alloc1 = 0 ;
9229 double val2 ;
9230 int ecode2 = 0 ;
9231 double val3 ;
9232 int ecode3 = 0 ;
9233 double val4 ;
9234 int ecode4 = 0 ;
9235 int res5 ;
9236 char *buf5 = 0 ;
9237 int alloc5 = 0 ;
9238 PyObject *swig_obj[5] ;
9239
9240 (void)self;
9241 if (!SWIG_Python_UnpackTuple(args, "plmtex", 5, 5, swig_obj)) SWIG_fail;
9242 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9243 if (!SWIG_IsOK(res1)) {
9244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
9245 }
9246 arg1 = (char *)(buf1);
9247 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9248 if (!SWIG_IsOK(ecode2)) {
9249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9250 }
9251 arg2 = (PLFLT)(val2);
9252 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9253 if (!SWIG_IsOK(ecode3)) {
9254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9255 }
9256 arg3 = (PLFLT)(val3);
9257 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9258 if (!SWIG_IsOK(ecode4)) {
9259 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9260 }
9261 arg4 = (PLFLT)(val4);
9262 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9263 if (!SWIG_IsOK(res5)) {
9264 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9265 }
9266 arg5 = (char *)(buf5);
9267 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9268 resultobj = SWIG_Py_Void();
9269 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9270 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9271 return resultobj;
9272fail:
9273 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9274 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9275 return NULL;
9276}
9277
9278
9279SWIGINTERN PyObject *_wrap_plmtex3(PyObject *self, PyObject *args) {
9280 PyObject *resultobj = 0;
9281 char *arg1 = (char *) 0 ;
9282 PLFLT arg2 ;
9283 PLFLT arg3 ;
9284 PLFLT arg4 ;
9285 char *arg5 = (char *) 0 ;
9286 int res1 ;
9287 char *buf1 = 0 ;
9288 int alloc1 = 0 ;
9289 double val2 ;
9290 int ecode2 = 0 ;
9291 double val3 ;
9292 int ecode3 = 0 ;
9293 double val4 ;
9294 int ecode4 = 0 ;
9295 int res5 ;
9296 char *buf5 = 0 ;
9297 int alloc5 = 0 ;
9298 PyObject *swig_obj[5] ;
9299
9300 (void)self;
9301 if (!SWIG_Python_UnpackTuple(args, "plmtex3", 5, 5, swig_obj)) SWIG_fail;
9302 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9303 if (!SWIG_IsOK(res1)) {
9304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9305 }
9306 arg1 = (char *)(buf1);
9307 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9308 if (!SWIG_IsOK(ecode2)) {
9309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9310 }
9311 arg2 = (PLFLT)(val2);
9312 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9313 if (!SWIG_IsOK(ecode3)) {
9314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9315 }
9316 arg3 = (PLFLT)(val3);
9317 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9318 if (!SWIG_IsOK(ecode4)) {
9319 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9320 }
9321 arg4 = (PLFLT)(val4);
9322 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9323 if (!SWIG_IsOK(res5)) {
9324 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9325 }
9326 arg5 = (char *)(buf5);
9327 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9328 resultobj = SWIG_Py_Void();
9329 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9330 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9331 return resultobj;
9332fail:
9333 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9334 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9335 return NULL;
9336}
9337
9338
9339SWIGINTERN PyObject *_wrap_plot3d(PyObject *self, PyObject *args) {
9340 PyObject *resultobj = 0;
9341 PLFLT *arg1 = (PLFLT *) 0 ;
9342 PLFLT *arg2 = (PLFLT *) 0 ;
9343 PLFLT **arg3 = (PLFLT **) 0 ;
9344 PLINT arg4 ;
9345 PLINT arg5 ;
9346 PLINT arg6 ;
9347 PLBOOL arg7 ;
9348 PyArrayObject *tmp1 = NULL ;
9349 PyArrayObject *tmp2 = NULL ;
9350 PyArrayObject *tmp3 = NULL ;
9351 int val6 ;
9352 int ecode6 = 0 ;
9353 int val7 ;
9354 int ecode7 = 0 ;
9355 PyObject *swig_obj[5] ;
9356
9357 (void)self;
9358 if (!SWIG_Python_UnpackTuple(args, "plot3d", 5, 5, swig_obj)) SWIG_fail;
9359 {
9360 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9361 if ( tmp1 == NULL )
9362 return NULL;
9363 Xlen = PyArray_DIMS( tmp1 )[0];
9364 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9365 }
9366 {
9367 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9368 if ( tmp2 == NULL )
9369 return NULL;
9370 Ylen = PyArray_DIMS( tmp2 )[0];
9371 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9372 }
9373 {
9374 int i, size;
9375 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9376 if ( tmp3 == NULL )
9377 return NULL;
9378 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9379 {
9380 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9381 return NULL;
9382 }
9383 arg4 = PyArray_DIMS( tmp3 )[0];
9384 arg5 = PyArray_DIMS( tmp3 )[1];
9385 size = arg5;
9386 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9387 for ( i = 0; i < arg4; i++ )
9388 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9389 }
9390 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9391 if (!SWIG_IsOK(ecode6)) {
9392 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9393 }
9394 arg6 = (PLINT)(val6);
9395 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
9396 if (!SWIG_IsOK(ecode7)) {
9397 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9398 }
9399 arg7 = (PLBOOL)(val7);
9400 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9401 resultobj = SWIG_Py_Void();
9402 {
9403 Py_CLEAR( tmp1 );
9404 }
9405 {
9406 Py_CLEAR( tmp2 );
9407 }
9408 {
9409 Py_CLEAR( tmp3 );
9410 free( arg3 );
9411 }
9412 return resultobj;
9413fail:
9414 {
9415 Py_CLEAR( tmp1 );
9416 }
9417 {
9418 Py_CLEAR( tmp2 );
9419 }
9420 {
9421 Py_CLEAR( tmp3 );
9422 free( arg3 );
9423 }
9424 return NULL;
9425}
9426
9427
9428SWIGINTERN PyObject *_wrap_plot3dc(PyObject *self, PyObject *args) {
9429 PyObject *resultobj = 0;
9430 PLFLT *arg1 = (PLFLT *) 0 ;
9431 PLFLT *arg2 = (PLFLT *) 0 ;
9432 PLFLT **arg3 = (PLFLT **) 0 ;
9433 PLINT arg4 ;
9434 PLINT arg5 ;
9435 PLINT arg6 ;
9436 PLFLT *arg7 = (PLFLT *) 0 ;
9437 PLINT arg8 ;
9438 PyArrayObject *tmp1 = NULL ;
9439 PyArrayObject *tmp2 = NULL ;
9440 PyArrayObject *tmp3 = NULL ;
9441 int val6 ;
9442 int ecode6 = 0 ;
9443 PyArrayObject *tmp7 = NULL ;
9444 PyObject *swig_obj[5] ;
9445
9446 (void)self;
9447 if (!SWIG_Python_UnpackTuple(args, "plot3dc", 5, 5, swig_obj)) SWIG_fail;
9448 {
9449 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9450 if ( tmp1 == NULL )
9451 return NULL;
9452 Xlen = PyArray_DIMS( tmp1 )[0];
9453 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9454 }
9455 {
9456 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9457 if ( tmp2 == NULL )
9458 return NULL;
9459 Ylen = PyArray_DIMS( tmp2 )[0];
9460 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9461 }
9462 {
9463 int i, size;
9464 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9465 if ( tmp3 == NULL )
9466 return NULL;
9467 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9468 {
9469 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9470 return NULL;
9471 }
9472 arg4 = PyArray_DIMS( tmp3 )[0];
9473 arg5 = PyArray_DIMS( tmp3 )[1];
9474 size = arg5;
9475 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9476 for ( i = 0; i < arg4; i++ )
9477 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9478 }
9479 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9480 if (!SWIG_IsOK(ecode6)) {
9481 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9482 }
9483 arg6 = (PLINT)(val6);
9484 {
9485 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9486 if ( tmp7 == NULL )
9487 return NULL;
9488 arg8 = PyArray_DIMS( tmp7 )[0];
9489 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9490 }
9491 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9492 resultobj = SWIG_Py_Void();
9493 {
9494 Py_CLEAR( tmp1 );
9495 }
9496 {
9497 Py_CLEAR( tmp2 );
9498 }
9499 {
9500 Py_CLEAR( tmp3 );
9501 free( arg3 );
9502 }
9503 {
9504 Py_CLEAR( tmp7 );
9505 }
9506 return resultobj;
9507fail:
9508 {
9509 Py_CLEAR( tmp1 );
9510 }
9511 {
9512 Py_CLEAR( tmp2 );
9513 }
9514 {
9515 Py_CLEAR( tmp3 );
9516 free( arg3 );
9517 }
9518 {
9519 Py_CLEAR( tmp7 );
9520 }
9521 return NULL;
9522}
9523
9524
9525SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *self, PyObject *args) {
9526 PyObject *resultobj = 0;
9527 PLFLT *arg1 = (PLFLT *) 0 ;
9528 PLFLT *arg2 = (PLFLT *) 0 ;
9529 PLFLT **arg3 = (PLFLT **) 0 ;
9530 PLINT arg4 ;
9531 PLINT arg5 ;
9532 PLINT arg6 ;
9533 PLFLT *arg7 = (PLFLT *) 0 ;
9534 PLINT arg8 ;
9535 PLINT arg9 ;
9536 PLINT arg10 ;
9537 PLINT *arg11 = (PLINT *) 0 ;
9538 PLINT *arg12 = (PLINT *) 0 ;
9539 PyArrayObject *tmp1 = NULL ;
9540 PyArrayObject *tmp2 = NULL ;
9541 PyArrayObject *tmp3 = NULL ;
9542 int val6 ;
9543 int ecode6 = 0 ;
9544 PyArrayObject *tmp7 = NULL ;
9545 int val9 ;
9546 int ecode9 = 0 ;
9547 PyArrayObject *tmp10 = NULL ;
9548 PyArrayObject *tmp12 = NULL ;
9549 PyObject *swig_obj[8] ;
9550
9551 (void)self;
9552 if (!SWIG_Python_UnpackTuple(args, "plot3dcl", 8, 8, swig_obj)) SWIG_fail;
9553 {
9554 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9555 if ( tmp1 == NULL )
9556 return NULL;
9557 Xlen = PyArray_DIMS( tmp1 )[0];
9558 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9559 }
9560 {
9561 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9562 if ( tmp2 == NULL )
9563 return NULL;
9564 Ylen = PyArray_DIMS( tmp2 )[0];
9565 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9566 }
9567 {
9568 int i, size;
9569 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9570 if ( tmp3 == NULL )
9571 return NULL;
9572 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9573 {
9574 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9575 return NULL;
9576 }
9577 arg4 = PyArray_DIMS( tmp3 )[0];
9578 arg5 = PyArray_DIMS( tmp3 )[1];
9579 size = arg5;
9580 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9581 for ( i = 0; i < arg4; i++ )
9582 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9583 }
9584 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9585 if (!SWIG_IsOK(ecode6)) {
9586 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9587 }
9588 arg6 = (PLINT)(val6);
9589 {
9590 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9591 if ( tmp7 == NULL )
9592 return NULL;
9593 arg8 = PyArray_DIMS( tmp7 )[0];
9594 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9595 }
9596 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9597 if (!SWIG_IsOK(ecode9)) {
9598 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9599 }
9600 arg9 = (PLINT)(val9);
9601 {
9602 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9603 if ( tmp10 == NULL )
9604 return NULL;
9605 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9606 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9607 }
9608 {
9609 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9610 if ( tmp12 == NULL )
9611 return NULL;
9612 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9613 {
9614 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9615 return NULL;
9616 }
9617 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9618 }
9619 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);
9620 resultobj = SWIG_Py_Void();
9621 {
9622 Py_CLEAR( tmp1 );
9623 }
9624 {
9625 Py_CLEAR( tmp2 );
9626 }
9627 {
9628 Py_CLEAR( tmp3 );
9629 free( arg3 );
9630 }
9631 {
9632 Py_CLEAR( tmp7 );
9633 }
9634 {
9635 Py_CLEAR( tmp10 );
9636 }
9637 {
9638 Py_CLEAR( tmp12 );
9639 }
9640 return resultobj;
9641fail:
9642 {
9643 Py_CLEAR( tmp1 );
9644 }
9645 {
9646 Py_CLEAR( tmp2 );
9647 }
9648 {
9649 Py_CLEAR( tmp3 );
9650 free( arg3 );
9651 }
9652 {
9653 Py_CLEAR( tmp7 );
9654 }
9655 {
9656 Py_CLEAR( tmp10 );
9657 }
9658 {
9659 Py_CLEAR( tmp12 );
9660 }
9661 return NULL;
9662}
9663
9664
9665SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *self, PyObject *args) {
9666 PyObject *resultobj = 0;
9667 PLFLT *arg1 = (PLFLT *) 0 ;
9668 PLFLT *arg2 = (PLFLT *) 0 ;
9669 PLFLT **arg3 = (PLFLT **) 0 ;
9670 PLINT arg4 ;
9671 PLINT arg5 ;
9672 PLINT arg6 ;
9673 PLFLT *arg7 = (PLFLT *) 0 ;
9674 PLINT arg8 ;
9675 PyArrayObject *tmp1 = NULL ;
9676 PyArrayObject *tmp2 = NULL ;
9677 PyArrayObject *tmp3 = NULL ;
9678 int val6 ;
9679 int ecode6 = 0 ;
9680 PyArrayObject *tmp7 = NULL ;
9681 PyObject *swig_obj[5] ;
9682
9683 (void)self;
9684 if (!SWIG_Python_UnpackTuple(args, "plsurf3d", 5, 5, swig_obj)) SWIG_fail;
9685 {
9686 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9687 if ( tmp1 == NULL )
9688 return NULL;
9689 Xlen = PyArray_DIMS( tmp1 )[0];
9690 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9691 }
9692 {
9693 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9694 if ( tmp2 == NULL )
9695 return NULL;
9696 Ylen = PyArray_DIMS( tmp2 )[0];
9697 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9698 }
9699 {
9700 int i, size;
9701 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9702 if ( tmp3 == NULL )
9703 return NULL;
9704 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9705 {
9706 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9707 return NULL;
9708 }
9709 arg4 = PyArray_DIMS( tmp3 )[0];
9710 arg5 = PyArray_DIMS( tmp3 )[1];
9711 size = arg5;
9712 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9713 for ( i = 0; i < arg4; i++ )
9714 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9715 }
9716 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9717 if (!SWIG_IsOK(ecode6)) {
9718 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9719 }
9720 arg6 = (PLINT)(val6);
9721 {
9722 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9723 if ( tmp7 == NULL )
9724 return NULL;
9725 arg8 = PyArray_DIMS( tmp7 )[0];
9726 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9727 }
9728 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9729 resultobj = SWIG_Py_Void();
9730 {
9731 Py_CLEAR( tmp1 );
9732 }
9733 {
9734 Py_CLEAR( tmp2 );
9735 }
9736 {
9737 Py_CLEAR( tmp3 );
9738 free( arg3 );
9739 }
9740 {
9741 Py_CLEAR( tmp7 );
9742 }
9743 return resultobj;
9744fail:
9745 {
9746 Py_CLEAR( tmp1 );
9747 }
9748 {
9749 Py_CLEAR( tmp2 );
9750 }
9751 {
9752 Py_CLEAR( tmp3 );
9753 free( arg3 );
9754 }
9755 {
9756 Py_CLEAR( tmp7 );
9757 }
9758 return NULL;
9759}
9760
9761
9762SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *self, PyObject *args) {
9763 PyObject *resultobj = 0;
9764 PLFLT *arg1 = (PLFLT *) 0 ;
9765 PLFLT *arg2 = (PLFLT *) 0 ;
9766 PLFLT **arg3 = (PLFLT **) 0 ;
9767 PLINT arg4 ;
9768 PLINT arg5 ;
9769 PLINT arg6 ;
9770 PLFLT *arg7 = (PLFLT *) 0 ;
9771 PLINT arg8 ;
9772 PLINT arg9 ;
9773 PLINT arg10 ;
9774 PLINT *arg11 = (PLINT *) 0 ;
9775 PLINT *arg12 = (PLINT *) 0 ;
9776 PyArrayObject *tmp1 = NULL ;
9777 PyArrayObject *tmp2 = NULL ;
9778 PyArrayObject *tmp3 = NULL ;
9779 int val6 ;
9780 int ecode6 = 0 ;
9781 PyArrayObject *tmp7 = NULL ;
9782 int val9 ;
9783 int ecode9 = 0 ;
9784 PyArrayObject *tmp10 = NULL ;
9785 PyArrayObject *tmp12 = NULL ;
9786 PyObject *swig_obj[8] ;
9787
9788 (void)self;
9789 if (!SWIG_Python_UnpackTuple(args, "plsurf3dl", 8, 8, swig_obj)) SWIG_fail;
9790 {
9791 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9792 if ( tmp1 == NULL )
9793 return NULL;
9794 Xlen = PyArray_DIMS( tmp1 )[0];
9795 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9796 }
9797 {
9798 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9799 if ( tmp2 == NULL )
9800 return NULL;
9801 Ylen = PyArray_DIMS( tmp2 )[0];
9802 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9803 }
9804 {
9805 int i, size;
9806 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9807 if ( tmp3 == NULL )
9808 return NULL;
9809 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9810 {
9811 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9812 return NULL;
9813 }
9814 arg4 = PyArray_DIMS( tmp3 )[0];
9815 arg5 = PyArray_DIMS( tmp3 )[1];
9816 size = arg5;
9817 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9818 for ( i = 0; i < arg4; i++ )
9819 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9820 }
9821 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9822 if (!SWIG_IsOK(ecode6)) {
9823 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9824 }
9825 arg6 = (PLINT)(val6);
9826 {
9827 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9828 if ( tmp7 == NULL )
9829 return NULL;
9830 arg8 = PyArray_DIMS( tmp7 )[0];
9831 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9832 }
9833 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9834 if (!SWIG_IsOK(ecode9)) {
9835 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9836 }
9837 arg9 = (PLINT)(val9);
9838 {
9839 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9840 if ( tmp10 == NULL )
9841 return NULL;
9842 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9843 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9844 }
9845 {
9846 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9847 if ( tmp12 == NULL )
9848 return NULL;
9849 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9850 {
9851 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9852 return NULL;
9853 }
9854 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9855 }
9856 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);
9857 resultobj = SWIG_Py_Void();
9858 {
9859 Py_CLEAR( tmp1 );
9860 }
9861 {
9862 Py_CLEAR( tmp2 );
9863 }
9864 {
9865 Py_CLEAR( tmp3 );
9866 free( arg3 );
9867 }
9868 {
9869 Py_CLEAR( tmp7 );
9870 }
9871 {
9872 Py_CLEAR( tmp10 );
9873 }
9874 {
9875 Py_CLEAR( tmp12 );
9876 }
9877 return resultobj;
9878fail:
9879 {
9880 Py_CLEAR( tmp1 );
9881 }
9882 {
9883 Py_CLEAR( tmp2 );
9884 }
9885 {
9886 Py_CLEAR( tmp3 );
9887 free( arg3 );
9888 }
9889 {
9890 Py_CLEAR( tmp7 );
9891 }
9892 {
9893 Py_CLEAR( tmp10 );
9894 }
9895 {
9896 Py_CLEAR( tmp12 );
9897 }
9898 return NULL;
9899}
9900
9901
9902SWIGINTERN PyObject *_wrap_plparseopts(PyObject *self, PyObject *args) {
9903 PyObject *resultobj = 0;
9904 int *arg1 = (int *) 0 ;
9905 char **arg2 = (char **) 0 ;
9906 PLINT arg3 ;
9907 int tmp1 ;
9908 int val3 ;
9909 int ecode3 = 0 ;
9910 PyObject *swig_obj[2] ;
9911 PLINT result;
9912
9913 (void)self;
9914 if (!SWIG_Python_UnpackTuple(args, "plparseopts", 2, 2, swig_obj)) SWIG_fail;
9915 {
9916 int i;
9917 PyObject *unicode_string;
9918
9919 if ( !PyList_Check( swig_obj[0] ) )
9920 {
9921 PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9922 return NULL;
9923 }
9924 tmp1 = PyList_Size( swig_obj[0] );
9925 arg1 = &tmp1;
9926 arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9927 for ( i = 0; i < tmp1; i++ )
9928 {
9929 PyObject *s = PyList_GetItem( swig_obj[0], i );
9930 if ( PyString_Check( s ) )
9931 {
9932 arg2[i] = PyString_AsString( s );
9933 }
9934 else if ( PyUnicode_Check( s ) )
9935 {
9936 // unicode_string is never freed? memory leak here?
9937 unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9938 arg2[i] = PyBytes_AS_STRING( unicode_string );
9939 }
9940 else
9941 {
9942 free( arg2 );
9943 PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9944 return NULL;
9945 }
9946 }
9947 arg2[i] = 0;
9948 }
9949 ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
9950 if (!SWIG_IsOK(ecode3)) {
9951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9952 }
9953 arg3 = (PLINT)(val3);
9954 result = (PLINT)plparseopts(arg1,arg2,arg3);
9955 resultobj = SWIG_From_int((int)(result));
9956 {
9957 if ( arg2 )
9958 free( arg2 );
9959 }
9960 return resultobj;
9961fail:
9962 {
9963 if ( arg2 )
9964 free( arg2 );
9965 }
9966 return NULL;
9967}
9968
9969
9970SWIGINTERN PyObject *_wrap_plpat(PyObject *self, PyObject *args) {
9971 PyObject *resultobj = 0;
9972 PLINT arg1 ;
9973 PLINT *arg2 = (PLINT *) 0 ;
9974 PLINT *arg3 = (PLINT *) 0 ;
9975 PyArrayObject *tmp1 = NULL ;
9976 PyArrayObject *tmp3 = NULL ;
9977 PyObject *swig_obj[2] ;
9978
9979 (void)self;
9980 if (!SWIG_Python_UnpackTuple(args, "plpat", 2, 2, swig_obj)) SWIG_fail;
9981 {
9982 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
9983 if ( tmp1 == NULL )
9984 return NULL;
9985 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9986 arg2 = (PLINT *) PyArray_DATA( tmp1 );
9987 }
9988 {
9989 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
9990 if ( tmp3 == NULL )
9991 return NULL;
9992 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9993 {
9994 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9995 return NULL;
9996 }
9997 arg3 = (PLINT *) PyArray_DATA( tmp3 );
9998 }
9999 plpat(arg1,(int const *)arg2,(int const *)arg3);
10000 resultobj = SWIG_Py_Void();
10001 {
10002 Py_CLEAR( tmp1 );
10003 }
10004 {
10005 Py_CLEAR( tmp3 );
10006 }
10007 return resultobj;
10008fail:
10009 {
10010 Py_CLEAR( tmp1 );
10011 }
10012 {
10013 Py_CLEAR( tmp3 );
10014 }
10015 return NULL;
10016}
10017
10018
10019SWIGINTERN PyObject *_wrap_plpath(PyObject *self, PyObject *args) {
10020 PyObject *resultobj = 0;
10021 PLINT arg1 ;
10022 PLFLT arg2 ;
10023 PLFLT arg3 ;
10024 PLFLT arg4 ;
10025 PLFLT arg5 ;
10026 int val1 ;
10027 int ecode1 = 0 ;
10028 double val2 ;
10029 int ecode2 = 0 ;
10030 double val3 ;
10031 int ecode3 = 0 ;
10032 double val4 ;
10033 int ecode4 = 0 ;
10034 double val5 ;
10035 int ecode5 = 0 ;
10036 PyObject *swig_obj[5] ;
10037
10038 (void)self;
10039 if (!SWIG_Python_UnpackTuple(args, "plpath", 5, 5, swig_obj)) SWIG_fail;
10040 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10041 if (!SWIG_IsOK(ecode1)) {
10042 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
10043 }
10044 arg1 = (PLINT)(val1);
10045 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10046 if (!SWIG_IsOK(ecode2)) {
10047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
10048 }
10049 arg2 = (PLFLT)(val2);
10050 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10051 if (!SWIG_IsOK(ecode3)) {
10052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
10053 }
10054 arg3 = (PLFLT)(val3);
10055 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10056 if (!SWIG_IsOK(ecode4)) {
10057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
10058 }
10059 arg4 = (PLFLT)(val4);
10060 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10061 if (!SWIG_IsOK(ecode5)) {
10062 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
10063 }
10064 arg5 = (PLFLT)(val5);
10065 plpath(arg1,arg2,arg3,arg4,arg5);
10066 resultobj = SWIG_Py_Void();
10067 return resultobj;
10068fail:
10069 return NULL;
10070}
10071
10072
10073SWIGINTERN PyObject *_wrap_plpoin(PyObject *self, PyObject *args) {
10074 PyObject *resultobj = 0;
10075 PLINT arg1 ;
10076 PLFLT *arg2 = (PLFLT *) 0 ;
10077 PLFLT *arg3 = (PLFLT *) 0 ;
10078 PLINT arg4 ;
10079 PyArrayObject *tmp1 = NULL ;
10080 PyArrayObject *tmp3 = NULL ;
10081 int val4 ;
10082 int ecode4 = 0 ;
10083 PyObject *swig_obj[3] ;
10084
10085 (void)self;
10086 if (!SWIG_Python_UnpackTuple(args, "plpoin", 3, 3, swig_obj)) SWIG_fail;
10087 {
10088 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10089 if ( tmp1 == NULL )
10090 return NULL;
10091 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10092 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10093 }
10094 {
10095 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10096 if ( tmp3 == NULL )
10097 return NULL;
10098 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10099 {
10100 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10101 return NULL;
10102 }
10103 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10104 }
10105 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
10106 if (!SWIG_IsOK(ecode4)) {
10107 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
10108 }
10109 arg4 = (PLINT)(val4);
10110 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
10111 resultobj = SWIG_Py_Void();
10112 {
10113 Py_CLEAR( tmp1 );
10114 }
10115 {
10116 Py_CLEAR( tmp3 );
10117 }
10118 return resultobj;
10119fail:
10120 {
10121 Py_CLEAR( tmp1 );
10122 }
10123 {
10124 Py_CLEAR( tmp3 );
10125 }
10126 return NULL;
10127}
10128
10129
10130SWIGINTERN PyObject *_wrap_plpoin3(PyObject *self, PyObject *args) {
10131 PyObject *resultobj = 0;
10132 PLINT arg1 ;
10133 PLFLT *arg2 = (PLFLT *) 0 ;
10134 PLFLT *arg3 = (PLFLT *) 0 ;
10135 PLFLT *arg4 = (PLFLT *) 0 ;
10136 PLINT arg5 ;
10137 PyArrayObject *tmp1 = NULL ;
10138 PyArrayObject *tmp3 = NULL ;
10139 PyArrayObject *tmp4 = NULL ;
10140 int val5 ;
10141 int ecode5 = 0 ;
10142 PyObject *swig_obj[4] ;
10143
10144 (void)self;
10145 if (!SWIG_Python_UnpackTuple(args, "plpoin3", 4, 4, swig_obj)) SWIG_fail;
10146 {
10147 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10148 if ( tmp1 == NULL )
10149 return NULL;
10150 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10151 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10152 }
10153 {
10154 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10155 if ( tmp3 == NULL )
10156 return NULL;
10157 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10158 {
10159 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10160 return NULL;
10161 }
10162 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10163 }
10164 {
10165 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10166 if ( tmp4 == NULL )
10167 return NULL;
10168 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10169 {
10170 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10171 return NULL;
10172 }
10173 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10174 }
10175 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
10176 if (!SWIG_IsOK(ecode5)) {
10177 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
10178 }
10179 arg5 = (PLINT)(val5);
10180 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
10181 resultobj = SWIG_Py_Void();
10182 {
10183 Py_CLEAR( tmp1 );
10184 }
10185 {
10186 Py_CLEAR( tmp3 );
10187 }
10188 {
10189 Py_CLEAR( tmp4 );
10190 }
10191 return resultobj;
10192fail:
10193 {
10194 Py_CLEAR( tmp1 );
10195 }
10196 {
10197 Py_CLEAR( tmp3 );
10198 }
10199 {
10200 Py_CLEAR( tmp4 );
10201 }
10202 return NULL;
10203}
10204
10205
10206SWIGINTERN PyObject *_wrap_plpoly3(PyObject *self, PyObject *args) {
10207 PyObject *resultobj = 0;
10208 PLINT arg1 ;
10209 PLFLT *arg2 = (PLFLT *) 0 ;
10210 PLFLT *arg3 = (PLFLT *) 0 ;
10211 PLFLT *arg4 = (PLFLT *) 0 ;
10212 PLBOOL *arg5 = (PLBOOL *) 0 ;
10213 PLBOOL arg6 ;
10214 PyArrayObject *tmp1 = NULL ;
10215 PyArrayObject *tmp3 = NULL ;
10216 PyArrayObject *tmp4 = NULL ;
10217 PyArrayObject *tmp5 = NULL ;
10218 int val6 ;
10219 int ecode6 = 0 ;
10220 PyObject *swig_obj[5] ;
10221
10222 (void)self;
10223 if (!SWIG_Python_UnpackTuple(args, "plpoly3", 5, 5, swig_obj)) SWIG_fail;
10224 {
10225 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10226 if ( tmp1 == NULL )
10227 return NULL;
10228 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10229 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10230 }
10231 {
10232 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10233 if ( tmp3 == NULL )
10234 return NULL;
10235 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10236 {
10237 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10238 return NULL;
10239 }
10240 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10241 }
10242 {
10243 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10244 if ( tmp4 == NULL )
10245 return NULL;
10246 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10247 {
10248 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10249 return NULL;
10250 }
10251 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10252 }
10253 {
10254 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[3], NPY_PLINT, 1, 1 );
10255 if ( tmp5 == NULL )
10256 return NULL;
10257 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10258 {
10259 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10260 return NULL;
10261 }
10262 arg5 = (PLINT *) PyArray_DATA( tmp5 );
10263 }
10264 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
10265 if (!SWIG_IsOK(ecode6)) {
10266 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10267 }
10268 arg6 = (PLBOOL)(val6);
10269 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10270 resultobj = SWIG_Py_Void();
10271 {
10272 Py_CLEAR( tmp1 );
10273 }
10274 {
10275 Py_CLEAR( tmp3 );
10276 }
10277 {
10278 Py_CLEAR( tmp4 );
10279 }
10280 {
10281 Py_CLEAR( tmp5 );
10282 }
10283 return resultobj;
10284fail:
10285 {
10286 Py_CLEAR( tmp1 );
10287 }
10288 {
10289 Py_CLEAR( tmp3 );
10290 }
10291 {
10292 Py_CLEAR( tmp4 );
10293 }
10294 {
10295 Py_CLEAR( tmp5 );
10296 }
10297 return NULL;
10298}
10299
10300
10301SWIGINTERN PyObject *_wrap_plprec(PyObject *self, PyObject *args) {
10302 PyObject *resultobj = 0;
10303 PLINT arg1 ;
10304 PLINT arg2 ;
10305 int val1 ;
10306 int ecode1 = 0 ;
10307 int val2 ;
10308 int ecode2 = 0 ;
10309 PyObject *swig_obj[2] ;
10310
10311 (void)self;
10312 if (!SWIG_Python_UnpackTuple(args, "plprec", 2, 2, swig_obj)) SWIG_fail;
10313 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10314 if (!SWIG_IsOK(ecode1)) {
10315 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10316 }
10317 arg1 = (PLINT)(val1);
10318 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10319 if (!SWIG_IsOK(ecode2)) {
10320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10321 }
10322 arg2 = (PLINT)(val2);
10323 plprec(arg1,arg2);
10324 resultobj = SWIG_Py_Void();
10325 return resultobj;
10326fail:
10327 return NULL;
10328}
10329
10330
10331SWIGINTERN PyObject *_wrap_plpsty(PyObject *self, PyObject *args) {
10332 PyObject *resultobj = 0;
10333 PLINT arg1 ;
10334 int val1 ;
10335 int ecode1 = 0 ;
10336 PyObject *swig_obj[1] ;
10337
10338 (void)self;
10339 if (!args) SWIG_fail;
10340 swig_obj[0] = args;
10341 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10342 if (!SWIG_IsOK(ecode1)) {
10343 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10344 }
10345 arg1 = (PLINT)(val1);
10346 plpsty(arg1);
10347 resultobj = SWIG_Py_Void();
10348 return resultobj;
10349fail:
10350 return NULL;
10351}
10352
10353
10354SWIGINTERN PyObject *_wrap_plptex(PyObject *self, PyObject *args) {
10355 PyObject *resultobj = 0;
10356 PLFLT arg1 ;
10357 PLFLT arg2 ;
10358 PLFLT arg3 ;
10359 PLFLT arg4 ;
10360 PLFLT arg5 ;
10361 char *arg6 = (char *) 0 ;
10362 double val1 ;
10363 int ecode1 = 0 ;
10364 double val2 ;
10365 int ecode2 = 0 ;
10366 double val3 ;
10367 int ecode3 = 0 ;
10368 double val4 ;
10369 int ecode4 = 0 ;
10370 double val5 ;
10371 int ecode5 = 0 ;
10372 int res6 ;
10373 char *buf6 = 0 ;
10374 int alloc6 = 0 ;
10375 PyObject *swig_obj[6] ;
10376
10377 (void)self;
10378 if (!SWIG_Python_UnpackTuple(args, "plptex", 6, 6, swig_obj)) SWIG_fail;
10379 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10380 if (!SWIG_IsOK(ecode1)) {
10381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10382 }
10383 arg1 = (PLFLT)(val1);
10384 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10385 if (!SWIG_IsOK(ecode2)) {
10386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10387 }
10388 arg2 = (PLFLT)(val2);
10389 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10390 if (!SWIG_IsOK(ecode3)) {
10391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10392 }
10393 arg3 = (PLFLT)(val3);
10394 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10395 if (!SWIG_IsOK(ecode4)) {
10396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10397 }
10398 arg4 = (PLFLT)(val4);
10399 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10400 if (!SWIG_IsOK(ecode5)) {
10401 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10402 }
10403 arg5 = (PLFLT)(val5);
10404 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
10405 if (!SWIG_IsOK(res6)) {
10406 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10407 }
10408 arg6 = (char *)(buf6);
10409 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10410 resultobj = SWIG_Py_Void();
10411 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10412 return resultobj;
10413fail:
10414 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10415 return NULL;
10416}
10417
10418
10419SWIGINTERN PyObject *_wrap_plptex3(PyObject *self, PyObject *args) {
10420 PyObject *resultobj = 0;
10421 PLFLT arg1 ;
10422 PLFLT arg2 ;
10423 PLFLT arg3 ;
10424 PLFLT arg4 ;
10425 PLFLT arg5 ;
10426 PLFLT arg6 ;
10427 PLFLT arg7 ;
10428 PLFLT arg8 ;
10429 PLFLT arg9 ;
10430 PLFLT arg10 ;
10431 char *arg11 = (char *) 0 ;
10432 double val1 ;
10433 int ecode1 = 0 ;
10434 double val2 ;
10435 int ecode2 = 0 ;
10436 double val3 ;
10437 int ecode3 = 0 ;
10438 double val4 ;
10439 int ecode4 = 0 ;
10440 double val5 ;
10441 int ecode5 = 0 ;
10442 double val6 ;
10443 int ecode6 = 0 ;
10444 double val7 ;
10445 int ecode7 = 0 ;
10446 double val8 ;
10447 int ecode8 = 0 ;
10448 double val9 ;
10449 int ecode9 = 0 ;
10450 double val10 ;
10451 int ecode10 = 0 ;
10452 int res11 ;
10453 char *buf11 = 0 ;
10454 int alloc11 = 0 ;
10455 PyObject *swig_obj[11] ;
10456
10457 (void)self;
10458 if (!SWIG_Python_UnpackTuple(args, "plptex3", 11, 11, swig_obj)) SWIG_fail;
10459 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10460 if (!SWIG_IsOK(ecode1)) {
10461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10462 }
10463 arg1 = (PLFLT)(val1);
10464 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10465 if (!SWIG_IsOK(ecode2)) {
10466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10467 }
10468 arg2 = (PLFLT)(val2);
10469 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10470 if (!SWIG_IsOK(ecode3)) {
10471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10472 }
10473 arg3 = (PLFLT)(val3);
10474 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10475 if (!SWIG_IsOK(ecode4)) {
10476 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10477 }
10478 arg4 = (PLFLT)(val4);
10479 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10480 if (!SWIG_IsOK(ecode5)) {
10481 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10482 }
10483 arg5 = (PLFLT)(val5);
10484 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
10485 if (!SWIG_IsOK(ecode6)) {
10486 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10487 }
10488 arg6 = (PLFLT)(val6);
10489 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
10490 if (!SWIG_IsOK(ecode7)) {
10491 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10492 }
10493 arg7 = (PLFLT)(val7);
10494 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
10495 if (!SWIG_IsOK(ecode8)) {
10496 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10497 }
10498 arg8 = (PLFLT)(val8);
10499 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
10500 if (!SWIG_IsOK(ecode9)) {
10501 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10502 }
10503 arg9 = (PLFLT)(val9);
10504 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
10505 if (!SWIG_IsOK(ecode10)) {
10506 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10507 }
10508 arg10 = (PLFLT)(val10);
10509 res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
10510 if (!SWIG_IsOK(res11)) {
10511 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10512 }
10513 arg11 = (char *)(buf11);
10514 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10515 resultobj = SWIG_Py_Void();
10516 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10517 return resultobj;
10518fail:
10519 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10520 return NULL;
10521}
10522
10523
10524SWIGINTERN PyObject *_wrap_plrandd(PyObject *self, PyObject *args) {
10525 PyObject *resultobj = 0;
10526 PLFLT result;
10527
10528 (void)self;
10529 if (!SWIG_Python_UnpackTuple(args, "plrandd", 0, 0, 0)) SWIG_fail;
10530 result = (PLFLT)plrandd();
10531 resultobj = SWIG_From_double((double)(result));
10532 return resultobj;
10533fail:
10534 return NULL;
10535}
10536
10537
10538SWIGINTERN PyObject *_wrap_plreplot(PyObject *self, PyObject *args) {
10539 PyObject *resultobj = 0;
10540
10541 (void)self;
10542 if (!SWIG_Python_UnpackTuple(args, "plreplot", 0, 0, 0)) SWIG_fail;
10543 plreplot();
10544 resultobj = SWIG_Py_Void();
10545 return resultobj;
10546fail:
10547 return NULL;
10548}
10549
10550
10551SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *self, PyObject *args) {
10552 PyObject *resultobj = 0;
10553 PLFLT arg1 ;
10554 PLFLT arg2 ;
10555 PLFLT arg3 ;
10556 PLFLT *arg4 = (PLFLT *) 0 ;
10557 PLFLT *arg5 = (PLFLT *) 0 ;
10558 PLFLT *arg6 = (PLFLT *) 0 ;
10559 double val1 ;
10560 int ecode1 = 0 ;
10561 double val2 ;
10562 int ecode2 = 0 ;
10563 double val3 ;
10564 int ecode3 = 0 ;
10565 PLFLT temp4 ;
10566 int res4 = SWIG_TMPOBJ ;
10567 PLFLT temp5 ;
10568 int res5 = SWIG_TMPOBJ ;
10569 PLFLT temp6 ;
10570 int res6 = SWIG_TMPOBJ ;
10571 PyObject *swig_obj[3] ;
10572
10573 arg4 = &temp4;
10574 arg5 = &temp5;
10575 arg6 = &temp6;
10576 (void)self;
10577 if (!SWIG_Python_UnpackTuple(args, "plrgbhls", 3, 3, swig_obj)) SWIG_fail;
10578 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10579 if (!SWIG_IsOK(ecode1)) {
10580 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10581 }
10582 arg1 = (PLFLT)(val1);
10583 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10584 if (!SWIG_IsOK(ecode2)) {
10585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10586 }
10587 arg2 = (PLFLT)(val2);
10588 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10589 if (!SWIG_IsOK(ecode3)) {
10590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10591 }
10592 arg3 = (PLFLT)(val3);
10593 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10594 resultobj = SWIG_Py_Void();
10595 if (SWIG_IsTmpObj(res4)) {
10596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10597 } else {
10598 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10600 }
10601 if (SWIG_IsTmpObj(res5)) {
10602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10603 } else {
10604 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10606 }
10607 if (SWIG_IsTmpObj(res6)) {
10608 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10609 } else {
10610 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10612 }
10613 return resultobj;
10614fail:
10615 return NULL;
10616}
10617
10618
10619SWIGINTERN PyObject *_wrap_plschr(PyObject *self, PyObject *args) {
10620 PyObject *resultobj = 0;
10621 PLFLT arg1 ;
10622 PLFLT arg2 ;
10623 double val1 ;
10624 int ecode1 = 0 ;
10625 double val2 ;
10626 int ecode2 = 0 ;
10627 PyObject *swig_obj[2] ;
10628
10629 (void)self;
10630 if (!SWIG_Python_UnpackTuple(args, "plschr", 2, 2, swig_obj)) SWIG_fail;
10631 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10632 if (!SWIG_IsOK(ecode1)) {
10633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10634 }
10635 arg1 = (PLFLT)(val1);
10636 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10637 if (!SWIG_IsOK(ecode2)) {
10638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10639 }
10640 arg2 = (PLFLT)(val2);
10641 plschr(arg1,arg2);
10642 resultobj = SWIG_Py_Void();
10643 return resultobj;
10644fail:
10645 return NULL;
10646}
10647
10648
10649SWIGINTERN PyObject *_wrap_plscmap0(PyObject *self, PyObject *args) {
10650 PyObject *resultobj = 0;
10651 PLINT *arg1 = (PLINT *) 0 ;
10652 PLINT *arg2 = (PLINT *) 0 ;
10653 PLINT *arg3 = (PLINT *) 0 ;
10654 PLINT arg4 ;
10655 PyArrayObject *tmp1 = NULL ;
10656 PyArrayObject *tmp2 = NULL ;
10657 PyArrayObject *tmp3 = NULL ;
10658 PyObject *swig_obj[3] ;
10659
10660 (void)self;
10661 if (!SWIG_Python_UnpackTuple(args, "plscmap0", 3, 3, swig_obj)) SWIG_fail;
10662 {
10663 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10664 if ( tmp1 == NULL )
10665 return NULL;
10666 Alen = PyArray_DIMS( tmp1 )[0];
10667 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10668 }
10669 {
10670 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10671 if ( tmp2 == NULL )
10672 return NULL;
10673 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10674 {
10675 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10676 return NULL;
10677 }
10678 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10679 }
10680 {
10681 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10682 if ( tmp3 == NULL )
10683 return NULL;
10684 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10685 {
10686 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10687 return NULL;
10688 }
10689 arg4 = PyArray_DIMS( tmp3 )[0];
10690 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10691 }
10692 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10693 resultobj = SWIG_Py_Void();
10694 {
10695 Py_CLEAR( tmp1 );
10696 }
10697 {
10698 Py_CLEAR( tmp2 );
10699 }
10700 {
10701 Py_CLEAR( tmp3 );
10702 }
10703 return resultobj;
10704fail:
10705 {
10706 Py_CLEAR( tmp1 );
10707 }
10708 {
10709 Py_CLEAR( tmp2 );
10710 }
10711 {
10712 Py_CLEAR( tmp3 );
10713 }
10714 return NULL;
10715}
10716
10717
10718SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *self, PyObject *args) {
10719 PyObject *resultobj = 0;
10720 PLINT *arg1 = (PLINT *) 0 ;
10721 PLINT *arg2 = (PLINT *) 0 ;
10722 PLINT *arg3 = (PLINT *) 0 ;
10723 PLFLT *arg4 = (PLFLT *) 0 ;
10724 PLINT arg5 ;
10725 PyArrayObject *tmp1 = NULL ;
10726 PyArrayObject *tmp2 = NULL ;
10727 PyArrayObject *tmp3 = NULL ;
10728 PyArrayObject *tmp4 = NULL ;
10729 PyObject *swig_obj[4] ;
10730
10731 (void)self;
10732 if (!SWIG_Python_UnpackTuple(args, "plscmap0a", 4, 4, swig_obj)) SWIG_fail;
10733 {
10734 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10735 if ( tmp1 == NULL )
10736 return NULL;
10737 Alen = PyArray_DIMS( tmp1 )[0];
10738 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10739 }
10740 {
10741 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10742 if ( tmp2 == NULL )
10743 return NULL;
10744 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10745 {
10746 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10747 return NULL;
10748 }
10749 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10750 }
10751 {
10752 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10753 if ( tmp3 == NULL )
10754 return NULL;
10755 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10756 {
10757 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10758 return NULL;
10759 }
10760 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10761 }
10762 {
10763 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10764 if ( tmp4 == NULL )
10765 return NULL;
10766 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10767 {
10768 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10769 return NULL;
10770 }
10771 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10772 arg5 = PyArray_DIMS( tmp4 )[0];
10773 }
10774 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10775 resultobj = SWIG_Py_Void();
10776 {
10777 Py_CLEAR( tmp1 );
10778 }
10779 {
10780 Py_CLEAR( tmp2 );
10781 }
10782 {
10783 Py_CLEAR( tmp3 );
10784 }
10785 {
10786 Py_CLEAR( tmp4 );
10787 }
10788 return resultobj;
10789fail:
10790 {
10791 Py_CLEAR( tmp1 );
10792 }
10793 {
10794 Py_CLEAR( tmp2 );
10795 }
10796 {
10797 Py_CLEAR( tmp3 );
10798 }
10799 {
10800 Py_CLEAR( tmp4 );
10801 }
10802 return NULL;
10803}
10804
10805
10806SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *self, PyObject *args) {
10807 PyObject *resultobj = 0;
10808 PLINT arg1 ;
10809 int val1 ;
10810 int ecode1 = 0 ;
10811 PyObject *swig_obj[1] ;
10812
10813 (void)self;
10814 if (!args) SWIG_fail;
10815 swig_obj[0] = args;
10816 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10817 if (!SWIG_IsOK(ecode1)) {
10818 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10819 }
10820 arg1 = (PLINT)(val1);
10821 plscmap0n(arg1);
10822 resultobj = SWIG_Py_Void();
10823 return resultobj;
10824fail:
10825 return NULL;
10826}
10827
10828
10829SWIGINTERN PyObject *_wrap_plscmap1(PyObject *self, PyObject *args) {
10830 PyObject *resultobj = 0;
10831 PLINT *arg1 = (PLINT *) 0 ;
10832 PLINT *arg2 = (PLINT *) 0 ;
10833 PLINT *arg3 = (PLINT *) 0 ;
10834 PLINT arg4 ;
10835 PyArrayObject *tmp1 = NULL ;
10836 PyArrayObject *tmp2 = NULL ;
10837 PyArrayObject *tmp3 = NULL ;
10838 PyObject *swig_obj[3] ;
10839
10840 (void)self;
10841 if (!SWIG_Python_UnpackTuple(args, "plscmap1", 3, 3, swig_obj)) SWIG_fail;
10842 {
10843 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10844 if ( tmp1 == NULL )
10845 return NULL;
10846 Alen = PyArray_DIMS( tmp1 )[0];
10847 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10848 }
10849 {
10850 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10851 if ( tmp2 == NULL )
10852 return NULL;
10853 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10854 {
10855 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10856 return NULL;
10857 }
10858 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10859 }
10860 {
10861 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10862 if ( tmp3 == NULL )
10863 return NULL;
10864 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10865 {
10866 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10867 return NULL;
10868 }
10869 arg4 = PyArray_DIMS( tmp3 )[0];
10870 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10871 }
10872 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10873 resultobj = SWIG_Py_Void();
10874 {
10875 Py_CLEAR( tmp1 );
10876 }
10877 {
10878 Py_CLEAR( tmp2 );
10879 }
10880 {
10881 Py_CLEAR( tmp3 );
10882 }
10883 return resultobj;
10884fail:
10885 {
10886 Py_CLEAR( tmp1 );
10887 }
10888 {
10889 Py_CLEAR( tmp2 );
10890 }
10891 {
10892 Py_CLEAR( tmp3 );
10893 }
10894 return NULL;
10895}
10896
10897
10898SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *self, PyObject *args) {
10899 PyObject *resultobj = 0;
10900 PLINT *arg1 = (PLINT *) 0 ;
10901 PLINT *arg2 = (PLINT *) 0 ;
10902 PLINT *arg3 = (PLINT *) 0 ;
10903 PLFLT *arg4 = (PLFLT *) 0 ;
10904 PLINT arg5 ;
10905 PyArrayObject *tmp1 = NULL ;
10906 PyArrayObject *tmp2 = NULL ;
10907 PyArrayObject *tmp3 = NULL ;
10908 PyArrayObject *tmp4 = NULL ;
10909 PyObject *swig_obj[4] ;
10910
10911 (void)self;
10912 if (!SWIG_Python_UnpackTuple(args, "plscmap1a", 4, 4, swig_obj)) SWIG_fail;
10913 {
10914 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10915 if ( tmp1 == NULL )
10916 return NULL;
10917 Alen = PyArray_DIMS( tmp1 )[0];
10918 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10919 }
10920 {
10921 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10922 if ( tmp2 == NULL )
10923 return NULL;
10924 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10925 {
10926 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10927 return NULL;
10928 }
10929 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10930 }
10931 {
10932 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10933 if ( tmp3 == NULL )
10934 return NULL;
10935 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10936 {
10937 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10938 return NULL;
10939 }
10940 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10941 }
10942 {
10943 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10944 if ( tmp4 == NULL )
10945 return NULL;
10946 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10947 {
10948 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10949 return NULL;
10950 }
10951 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10952 arg5 = PyArray_DIMS( tmp4 )[0];
10953 }
10954 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10955 resultobj = SWIG_Py_Void();
10956 {
10957 Py_CLEAR( tmp1 );
10958 }
10959 {
10960 Py_CLEAR( tmp2 );
10961 }
10962 {
10963 Py_CLEAR( tmp3 );
10964 }
10965 {
10966 Py_CLEAR( tmp4 );
10967 }
10968 return resultobj;
10969fail:
10970 {
10971 Py_CLEAR( tmp1 );
10972 }
10973 {
10974 Py_CLEAR( tmp2 );
10975 }
10976 {
10977 Py_CLEAR( tmp3 );
10978 }
10979 {
10980 Py_CLEAR( tmp4 );
10981 }
10982 return NULL;
10983}
10984
10985
10986SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *self, PyObject *args) {
10987 PyObject *resultobj = 0;
10988 PLBOOL arg1 ;
10989 PLINT arg2 ;
10990 PLFLT *arg3 = (PLFLT *) 0 ;
10991 PLFLT *arg4 = (PLFLT *) 0 ;
10992 PLFLT *arg5 = (PLFLT *) 0 ;
10993 PLFLT *arg6 = (PLFLT *) 0 ;
10994 PLBOOL *arg7 = (PLBOOL *) 0 ;
10995 int val1 ;
10996 int ecode1 = 0 ;
10997 PyArrayObject *tmp2 = NULL ;
10998 PyArrayObject *tmp4 = NULL ;
10999 PyArrayObject *tmp5 = NULL ;
11000 PyArrayObject *tmp6 = NULL ;
11001 PyArrayObject *tmp7 = NULL ;
11002 PyObject *swig_obj[6] ;
11003
11004 (void)self;
11005 if (!SWIG_Python_UnpackTuple(args, "plscmap1l", 6, 6, swig_obj)) SWIG_fail;
11006 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11007 if (!SWIG_IsOK(ecode1)) {
11008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
11009 }
11010 arg1 = (PLBOOL)(val1);
11011 {
11012 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11013 if ( tmp2 == NULL )
11014 return NULL;
11015 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11016 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11017 }
11018 {
11019 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11020 if ( tmp4 == NULL )
11021 return NULL;
11022 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11023 {
11024 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11025 return NULL;
11026 }
11027 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11028 }
11029 {
11030 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11031 if ( tmp5 == NULL )
11032 return NULL;
11033 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11034 {
11035 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11036 return NULL;
11037 }
11038 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11039 }
11040 {
11041 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11042 if ( tmp6 == NULL )
11043 return NULL;
11044 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11045 {
11046 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11047 return NULL;
11048 }
11049 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11050 }
11051 {
11052 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[5], NPY_PLINT, 1, 1 );
11053 if ( tmp7 == NULL )
11054 return NULL;
11055 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
11056 {
11057 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11058 return NULL;
11059 }
11060 arg7 = (PLINT *) PyArray_DATA( tmp7 );
11061 }
11062 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
11063 resultobj = SWIG_Py_Void();
11064 {
11065 Py_CLEAR( tmp2 );
11066 }
11067 {
11068 Py_CLEAR( tmp4 );
11069 }
11070 {
11071 Py_CLEAR( tmp5 );
11072 }
11073 {
11074 Py_CLEAR( tmp6 );
11075 }
11076 {
11077 Py_CLEAR( tmp7 );
11078 }
11079 return resultobj;
11080fail:
11081 {
11082 Py_CLEAR( tmp2 );
11083 }
11084 {
11085 Py_CLEAR( tmp4 );
11086 }
11087 {
11088 Py_CLEAR( tmp5 );
11089 }
11090 {
11091 Py_CLEAR( tmp6 );
11092 }
11093 {
11094 Py_CLEAR( tmp7 );
11095 }
11096 return NULL;
11097}
11098
11099
11100SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *self, PyObject *args) {
11101 PyObject *resultobj = 0;
11102 PLBOOL arg1 ;
11103 PLINT arg2 ;
11104 PLFLT *arg3 = (PLFLT *) 0 ;
11105 PLFLT *arg4 = (PLFLT *) 0 ;
11106 PLFLT *arg5 = (PLFLT *) 0 ;
11107 PLFLT *arg6 = (PLFLT *) 0 ;
11108 PLFLT *arg7 = (PLFLT *) 0 ;
11109 PLBOOL *arg8 = (PLBOOL *) 0 ;
11110 int val1 ;
11111 int ecode1 = 0 ;
11112 PyArrayObject *tmp2 = NULL ;
11113 PyArrayObject *tmp4 = NULL ;
11114 PyArrayObject *tmp5 = NULL ;
11115 PyArrayObject *tmp6 = NULL ;
11116 PyArrayObject *tmp7 = NULL ;
11117 PyArrayObject *tmp8 = NULL ;
11118 PyObject *swig_obj[7] ;
11119
11120 (void)self;
11121 if (!SWIG_Python_UnpackTuple(args, "plscmap1la", 7, 7, swig_obj)) SWIG_fail;
11122 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11123 if (!SWIG_IsOK(ecode1)) {
11124 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
11125 }
11126 arg1 = (PLBOOL)(val1);
11127 {
11128 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11129 if ( tmp2 == NULL )
11130 return NULL;
11131 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11132 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11133 }
11134 {
11135 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11136 if ( tmp4 == NULL )
11137 return NULL;
11138 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11139 {
11140 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11141 return NULL;
11142 }
11143 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11144 }
11145 {
11146 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11147 if ( tmp5 == NULL )
11148 return NULL;
11149 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11150 {
11151 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11152 return NULL;
11153 }
11154 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11155 }
11156 {
11157 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11158 if ( tmp6 == NULL )
11159 return NULL;
11160 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11161 {
11162 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11163 return NULL;
11164 }
11165 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11166 }
11167 {
11168 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
11169 if ( tmp7 == NULL )
11170 return NULL;
11171 if ( PyArray_DIMS( tmp7 )[0] != Alen )
11172 {
11173 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11174 return NULL;
11175 }
11176 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
11177 }
11178 {
11179 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
11180 if ( tmp8 == NULL )
11181 return NULL;
11182 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
11183 {
11184 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11185 return NULL;
11186 }
11187 arg8 = (PLINT *) PyArray_DATA( tmp8 );
11188 }
11189 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
11190 resultobj = SWIG_Py_Void();
11191 {
11192 Py_CLEAR( tmp2 );
11193 }
11194 {
11195 Py_CLEAR( tmp4 );
11196 }
11197 {
11198 Py_CLEAR( tmp5 );
11199 }
11200 {
11201 Py_CLEAR( tmp6 );
11202 }
11203 {
11204 Py_CLEAR( tmp7 );
11205 }
11206 {
11207 Py_CLEAR( tmp8 );
11208 }
11209 return resultobj;
11210fail:
11211 {
11212 Py_CLEAR( tmp2 );
11213 }
11214 {
11215 Py_CLEAR( tmp4 );
11216 }
11217 {
11218 Py_CLEAR( tmp5 );
11219 }
11220 {
11221 Py_CLEAR( tmp6 );
11222 }
11223 {
11224 Py_CLEAR( tmp7 );
11225 }
11226 {
11227 Py_CLEAR( tmp8 );
11228 }
11229 return NULL;
11230}
11231
11232
11233SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *self, PyObject *args) {
11234 PyObject *resultobj = 0;
11235 PLINT arg1 ;
11236 int val1 ;
11237 int ecode1 = 0 ;
11238 PyObject *swig_obj[1] ;
11239
11240 (void)self;
11241 if (!args) SWIG_fail;
11242 swig_obj[0] = args;
11243 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11244 if (!SWIG_IsOK(ecode1)) {
11245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11246 }
11247 arg1 = (PLINT)(val1);
11248 plscmap1n(arg1);
11249 resultobj = SWIG_Py_Void();
11250 return resultobj;
11251fail:
11252 return NULL;
11253}
11254
11255
11256SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *self, PyObject *args) {
11257 PyObject *resultobj = 0;
11258 PLFLT arg1 ;
11259 PLFLT arg2 ;
11260 double val1 ;
11261 int ecode1 = 0 ;
11262 double val2 ;
11263 int ecode2 = 0 ;
11264 PyObject *swig_obj[2] ;
11265
11266 (void)self;
11267 if (!SWIG_Python_UnpackTuple(args, "plscmap1_range", 2, 2, swig_obj)) SWIG_fail;
11268 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11269 if (!SWIG_IsOK(ecode1)) {
11270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11271 }
11272 arg1 = (PLFLT)(val1);
11273 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11274 if (!SWIG_IsOK(ecode2)) {
11275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11276 }
11277 arg2 = (PLFLT)(val2);
11278 plscmap1_range(arg1,arg2);
11279 resultobj = SWIG_Py_Void();
11280 return resultobj;
11281fail:
11282 return NULL;
11283}
11284
11285
11286SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *self, PyObject *args) {
11287 PyObject *resultobj = 0;
11288 PLFLT *arg1 = (PLFLT *) 0 ;
11289 PLFLT *arg2 = (PLFLT *) 0 ;
11290 PLFLT temp1 ;
11291 int res1 = SWIG_TMPOBJ ;
11292 PLFLT temp2 ;
11293 int res2 = SWIG_TMPOBJ ;
11294
11295 arg1 = &temp1;
11296 arg2 = &temp2;
11297 (void)self;
11298 if (!SWIG_Python_UnpackTuple(args, "plgcmap1_range", 0, 0, 0)) SWIG_fail;
11299 plgcmap1_range(arg1,arg2);
11300 resultobj = SWIG_Py_Void();
11301 if (SWIG_IsTmpObj(res1)) {
11302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
11303 } else {
11304 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11305 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11306 }
11307 if (SWIG_IsTmpObj(res2)) {
11308 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
11309 } else {
11310 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11311 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11312 }
11313 return resultobj;
11314fail:
11315 return NULL;
11316}
11317
11318
11319SWIGINTERN PyObject *_wrap_plscol0(PyObject *self, PyObject *args) {
11320 PyObject *resultobj = 0;
11321 PLINT arg1 ;
11322 PLINT arg2 ;
11323 PLINT arg3 ;
11324 PLINT arg4 ;
11325 int val1 ;
11326 int ecode1 = 0 ;
11327 int val2 ;
11328 int ecode2 = 0 ;
11329 int val3 ;
11330 int ecode3 = 0 ;
11331 int val4 ;
11332 int ecode4 = 0 ;
11333 PyObject *swig_obj[4] ;
11334
11335 (void)self;
11336 if (!SWIG_Python_UnpackTuple(args, "plscol0", 4, 4, swig_obj)) SWIG_fail;
11337 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11338 if (!SWIG_IsOK(ecode1)) {
11339 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11340 }
11341 arg1 = (PLINT)(val1);
11342 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11343 if (!SWIG_IsOK(ecode2)) {
11344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11345 }
11346 arg2 = (PLINT)(val2);
11347 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11348 if (!SWIG_IsOK(ecode3)) {
11349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11350 }
11351 arg3 = (PLINT)(val3);
11352 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11353 if (!SWIG_IsOK(ecode4)) {
11354 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11355 }
11356 arg4 = (PLINT)(val4);
11357 plscol0(arg1,arg2,arg3,arg4);
11358 resultobj = SWIG_Py_Void();
11359 return resultobj;
11360fail:
11361 return NULL;
11362}
11363
11364
11365SWIGINTERN PyObject *_wrap_plscol0a(PyObject *self, PyObject *args) {
11366 PyObject *resultobj = 0;
11367 PLINT arg1 ;
11368 PLINT arg2 ;
11369 PLINT arg3 ;
11370 PLINT arg4 ;
11371 PLFLT arg5 ;
11372 int val1 ;
11373 int ecode1 = 0 ;
11374 int val2 ;
11375 int ecode2 = 0 ;
11376 int val3 ;
11377 int ecode3 = 0 ;
11378 int val4 ;
11379 int ecode4 = 0 ;
11380 double val5 ;
11381 int ecode5 = 0 ;
11382 PyObject *swig_obj[5] ;
11383
11384 (void)self;
11385 if (!SWIG_Python_UnpackTuple(args, "plscol0a", 5, 5, swig_obj)) SWIG_fail;
11386 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11387 if (!SWIG_IsOK(ecode1)) {
11388 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11389 }
11390 arg1 = (PLINT)(val1);
11391 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11392 if (!SWIG_IsOK(ecode2)) {
11393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11394 }
11395 arg2 = (PLINT)(val2);
11396 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11397 if (!SWIG_IsOK(ecode3)) {
11398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11399 }
11400 arg3 = (PLINT)(val3);
11401 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11402 if (!SWIG_IsOK(ecode4)) {
11403 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11404 }
11405 arg4 = (PLINT)(val4);
11406 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11407 if (!SWIG_IsOK(ecode5)) {
11408 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11409 }
11410 arg5 = (PLFLT)(val5);
11411 plscol0a(arg1,arg2,arg3,arg4,arg5);
11412 resultobj = SWIG_Py_Void();
11413 return resultobj;
11414fail:
11415 return NULL;
11416}
11417
11418
11419SWIGINTERN PyObject *_wrap_plscolbg(PyObject *self, PyObject *args) {
11420 PyObject *resultobj = 0;
11421 PLINT arg1 ;
11422 PLINT arg2 ;
11423 PLINT arg3 ;
11424 int val1 ;
11425 int ecode1 = 0 ;
11426 int val2 ;
11427 int ecode2 = 0 ;
11428 int val3 ;
11429 int ecode3 = 0 ;
11430 PyObject *swig_obj[3] ;
11431
11432 (void)self;
11433 if (!SWIG_Python_UnpackTuple(args, "plscolbg", 3, 3, swig_obj)) SWIG_fail;
11434 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11435 if (!SWIG_IsOK(ecode1)) {
11436 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11437 }
11438 arg1 = (PLINT)(val1);
11439 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11440 if (!SWIG_IsOK(ecode2)) {
11441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11442 }
11443 arg2 = (PLINT)(val2);
11444 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11445 if (!SWIG_IsOK(ecode3)) {
11446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11447 }
11448 arg3 = (PLINT)(val3);
11449 plscolbg(arg1,arg2,arg3);
11450 resultobj = SWIG_Py_Void();
11451 return resultobj;
11452fail:
11453 return NULL;
11454}
11455
11456
11457SWIGINTERN PyObject *_wrap_plscolbga(PyObject *self, PyObject *args) {
11458 PyObject *resultobj = 0;
11459 PLINT arg1 ;
11460 PLINT arg2 ;
11461 PLINT arg3 ;
11462 PLFLT arg4 ;
11463 int val1 ;
11464 int ecode1 = 0 ;
11465 int val2 ;
11466 int ecode2 = 0 ;
11467 int val3 ;
11468 int ecode3 = 0 ;
11469 double val4 ;
11470 int ecode4 = 0 ;
11471 PyObject *swig_obj[4] ;
11472
11473 (void)self;
11474 if (!SWIG_Python_UnpackTuple(args, "plscolbga", 4, 4, swig_obj)) SWIG_fail;
11475 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11476 if (!SWIG_IsOK(ecode1)) {
11477 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11478 }
11479 arg1 = (PLINT)(val1);
11480 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11481 if (!SWIG_IsOK(ecode2)) {
11482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11483 }
11484 arg2 = (PLINT)(val2);
11485 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11486 if (!SWIG_IsOK(ecode3)) {
11487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11488 }
11489 arg3 = (PLINT)(val3);
11490 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11491 if (!SWIG_IsOK(ecode4)) {
11492 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11493 }
11494 arg4 = (PLFLT)(val4);
11495 plscolbga(arg1,arg2,arg3,arg4);
11496 resultobj = SWIG_Py_Void();
11497 return resultobj;
11498fail:
11499 return NULL;
11500}
11501
11502
11503SWIGINTERN PyObject *_wrap_plscolor(PyObject *self, PyObject *args) {
11504 PyObject *resultobj = 0;
11505 PLINT arg1 ;
11506 int val1 ;
11507 int ecode1 = 0 ;
11508 PyObject *swig_obj[1] ;
11509
11510 (void)self;
11511 if (!args) SWIG_fail;
11512 swig_obj[0] = args;
11513 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11514 if (!SWIG_IsOK(ecode1)) {
11515 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11516 }
11517 arg1 = (PLINT)(val1);
11518 plscolor(arg1);
11519 resultobj = SWIG_Py_Void();
11520 return resultobj;
11521fail:
11522 return NULL;
11523}
11524
11525
11526SWIGINTERN PyObject *_wrap_plscompression(PyObject *self, PyObject *args) {
11527 PyObject *resultobj = 0;
11528 PLINT arg1 ;
11529 int val1 ;
11530 int ecode1 = 0 ;
11531 PyObject *swig_obj[1] ;
11532
11533 (void)self;
11534 if (!args) SWIG_fail;
11535 swig_obj[0] = args;
11536 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11537 if (!SWIG_IsOK(ecode1)) {
11538 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11539 }
11540 arg1 = (PLINT)(val1);
11541 plscompression(arg1);
11542 resultobj = SWIG_Py_Void();
11543 return resultobj;
11544fail:
11545 return NULL;
11546}
11547
11548
11549SWIGINTERN PyObject *_wrap_plsdev(PyObject *self, PyObject *args) {
11550 PyObject *resultobj = 0;
11551 char *arg1 = (char *) 0 ;
11552 int res1 ;
11553 char *buf1 = 0 ;
11554 int alloc1 = 0 ;
11555 PyObject *swig_obj[1] ;
11556
11557 (void)self;
11558 if (!args) SWIG_fail;
11559 swig_obj[0] = args;
11560 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11561 if (!SWIG_IsOK(res1)) {
11562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11563 }
11564 arg1 = (char *)(buf1);
11565 plsdev((char const *)arg1);
11566 resultobj = SWIG_Py_Void();
11567 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11568 return resultobj;
11569fail:
11570 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11571 return NULL;
11572}
11573
11574
11575SWIGINTERN PyObject *_wrap_plsdidev(PyObject *self, PyObject *args) {
11576 PyObject *resultobj = 0;
11577 PLFLT arg1 ;
11578 PLFLT arg2 ;
11579 PLFLT arg3 ;
11580 PLFLT arg4 ;
11581 double val1 ;
11582 int ecode1 = 0 ;
11583 double val2 ;
11584 int ecode2 = 0 ;
11585 double val3 ;
11586 int ecode3 = 0 ;
11587 double val4 ;
11588 int ecode4 = 0 ;
11589 PyObject *swig_obj[4] ;
11590
11591 (void)self;
11592 if (!SWIG_Python_UnpackTuple(args, "plsdidev", 4, 4, swig_obj)) SWIG_fail;
11593 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11594 if (!SWIG_IsOK(ecode1)) {
11595 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11596 }
11597 arg1 = (PLFLT)(val1);
11598 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11599 if (!SWIG_IsOK(ecode2)) {
11600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11601 }
11602 arg2 = (PLFLT)(val2);
11603 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11604 if (!SWIG_IsOK(ecode3)) {
11605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11606 }
11607 arg3 = (PLFLT)(val3);
11608 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11609 if (!SWIG_IsOK(ecode4)) {
11610 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11611 }
11612 arg4 = (PLFLT)(val4);
11613 plsdidev(arg1,arg2,arg3,arg4);
11614 resultobj = SWIG_Py_Void();
11615 return resultobj;
11616fail:
11617 return NULL;
11618}
11619
11620
11621SWIGINTERN PyObject *_wrap_plsdimap(PyObject *self, PyObject *args) {
11622 PyObject *resultobj = 0;
11623 PLINT arg1 ;
11624 PLINT arg2 ;
11625 PLINT arg3 ;
11626 PLINT arg4 ;
11627 PLFLT arg5 ;
11628 PLFLT arg6 ;
11629 int val1 ;
11630 int ecode1 = 0 ;
11631 int val2 ;
11632 int ecode2 = 0 ;
11633 int val3 ;
11634 int ecode3 = 0 ;
11635 int val4 ;
11636 int ecode4 = 0 ;
11637 double val5 ;
11638 int ecode5 = 0 ;
11639 double val6 ;
11640 int ecode6 = 0 ;
11641 PyObject *swig_obj[6] ;
11642
11643 (void)self;
11644 if (!SWIG_Python_UnpackTuple(args, "plsdimap", 6, 6, swig_obj)) SWIG_fail;
11645 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11646 if (!SWIG_IsOK(ecode1)) {
11647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11648 }
11649 arg1 = (PLINT)(val1);
11650 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11651 if (!SWIG_IsOK(ecode2)) {
11652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11653 }
11654 arg2 = (PLINT)(val2);
11655 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11656 if (!SWIG_IsOK(ecode3)) {
11657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11658 }
11659 arg3 = (PLINT)(val3);
11660 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11661 if (!SWIG_IsOK(ecode4)) {
11662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11663 }
11664 arg4 = (PLINT)(val4);
11665 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11666 if (!SWIG_IsOK(ecode5)) {
11667 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11668 }
11669 arg5 = (PLFLT)(val5);
11670 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
11671 if (!SWIG_IsOK(ecode6)) {
11672 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11673 }
11674 arg6 = (PLFLT)(val6);
11675 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11676 resultobj = SWIG_Py_Void();
11677 return resultobj;
11678fail:
11679 return NULL;
11680}
11681
11682
11683SWIGINTERN PyObject *_wrap_plsdiori(PyObject *self, PyObject *args) {
11684 PyObject *resultobj = 0;
11685 PLFLT arg1 ;
11686 double val1 ;
11687 int ecode1 = 0 ;
11688 PyObject *swig_obj[1] ;
11689
11690 (void)self;
11691 if (!args) SWIG_fail;
11692 swig_obj[0] = args;
11693 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11694 if (!SWIG_IsOK(ecode1)) {
11695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11696 }
11697 arg1 = (PLFLT)(val1);
11698 plsdiori(arg1);
11699 resultobj = SWIG_Py_Void();
11700 return resultobj;
11701fail:
11702 return NULL;
11703}
11704
11705
11706SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *self, PyObject *args) {
11707 PyObject *resultobj = 0;
11708 PLFLT arg1 ;
11709 PLFLT arg2 ;
11710 PLFLT arg3 ;
11711 PLFLT arg4 ;
11712 double val1 ;
11713 int ecode1 = 0 ;
11714 double val2 ;
11715 int ecode2 = 0 ;
11716 double val3 ;
11717 int ecode3 = 0 ;
11718 double val4 ;
11719 int ecode4 = 0 ;
11720 PyObject *swig_obj[4] ;
11721
11722 (void)self;
11723 if (!SWIG_Python_UnpackTuple(args, "plsdiplt", 4, 4, swig_obj)) SWIG_fail;
11724 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11725 if (!SWIG_IsOK(ecode1)) {
11726 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11727 }
11728 arg1 = (PLFLT)(val1);
11729 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11730 if (!SWIG_IsOK(ecode2)) {
11731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11732 }
11733 arg2 = (PLFLT)(val2);
11734 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11735 if (!SWIG_IsOK(ecode3)) {
11736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11737 }
11738 arg3 = (PLFLT)(val3);
11739 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11740 if (!SWIG_IsOK(ecode4)) {
11741 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11742 }
11743 arg4 = (PLFLT)(val4);
11744 plsdiplt(arg1,arg2,arg3,arg4);
11745 resultobj = SWIG_Py_Void();
11746 return resultobj;
11747fail:
11748 return NULL;
11749}
11750
11751
11752SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *self, PyObject *args) {
11753 PyObject *resultobj = 0;
11754 PLFLT arg1 ;
11755 PLFLT arg2 ;
11756 PLFLT arg3 ;
11757 PLFLT arg4 ;
11758 double val1 ;
11759 int ecode1 = 0 ;
11760 double val2 ;
11761 int ecode2 = 0 ;
11762 double val3 ;
11763 int ecode3 = 0 ;
11764 double val4 ;
11765 int ecode4 = 0 ;
11766 PyObject *swig_obj[4] ;
11767
11768 (void)self;
11769 if (!SWIG_Python_UnpackTuple(args, "plsdiplz", 4, 4, swig_obj)) SWIG_fail;
11770 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11771 if (!SWIG_IsOK(ecode1)) {
11772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11773 }
11774 arg1 = (PLFLT)(val1);
11775 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11776 if (!SWIG_IsOK(ecode2)) {
11777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11778 }
11779 arg2 = (PLFLT)(val2);
11780 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11781 if (!SWIG_IsOK(ecode3)) {
11782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11783 }
11784 arg3 = (PLFLT)(val3);
11785 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11786 if (!SWIG_IsOK(ecode4)) {
11787 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11788 }
11789 arg4 = (PLFLT)(val4);
11790 plsdiplz(arg1,arg2,arg3,arg4);
11791 resultobj = SWIG_Py_Void();
11792 return resultobj;
11793fail:
11794 return NULL;
11795}
11796
11797
11798SWIGINTERN PyObject *_wrap_plseed(PyObject *self, PyObject *args) {
11799 PyObject *resultobj = 0;
11800 unsigned int arg1 ;
11801 unsigned int val1 ;
11802 int ecode1 = 0 ;
11803 PyObject *swig_obj[1] ;
11804
11805 (void)self;
11806 if (!args) SWIG_fail;
11807 swig_obj[0] = args;
11808 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11809 if (!SWIG_IsOK(ecode1)) {
11810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11811 }
11812 arg1 = (unsigned int)(val1);
11813 plseed(arg1);
11814 resultobj = SWIG_Py_Void();
11815 return resultobj;
11816fail:
11817 return NULL;
11818}
11819
11820
11821SWIGINTERN PyObject *_wrap_plsesc(PyObject *self, PyObject *args) {
11822 PyObject *resultobj = 0;
11823 char arg1 ;
11824 char val1 ;
11825 int ecode1 = 0 ;
11826 PyObject *swig_obj[1] ;
11827
11828 (void)self;
11829 if (!args) SWIG_fail;
11830 swig_obj[0] = args;
11831 ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
11832 if (!SWIG_IsOK(ecode1)) {
11833 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11834 }
11835 arg1 = (char)(val1);
11836 plsesc(arg1);
11837 resultobj = SWIG_Py_Void();
11838 return resultobj;
11839fail:
11840 return NULL;
11841}
11842
11843
11844SWIGINTERN PyObject *_wrap_plsetopt(PyObject *self, PyObject *args) {
11845 PyObject *resultobj = 0;
11846 char *arg1 = (char *) 0 ;
11847 char *arg2 = (char *) 0 ;
11848 int res1 ;
11849 char *buf1 = 0 ;
11850 int alloc1 = 0 ;
11851 int res2 ;
11852 char *buf2 = 0 ;
11853 int alloc2 = 0 ;
11854 PyObject *swig_obj[2] ;
11855 PLINT result;
11856
11857 (void)self;
11858 if (!SWIG_Python_UnpackTuple(args, "plsetopt", 2, 2, swig_obj)) SWIG_fail;
11859 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11860 if (!SWIG_IsOK(res1)) {
11861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11862 }
11863 arg1 = (char *)(buf1);
11864 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11865 if (!SWIG_IsOK(res2)) {
11866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11867 }
11868 arg2 = (char *)(buf2);
11869 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11870 resultobj = SWIG_From_int((int)(result));
11871 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11872 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11873 return resultobj;
11874fail:
11875 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11876 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11877 return NULL;
11878}
11879
11880
11881SWIGINTERN PyObject *_wrap_plsfam(PyObject *self, PyObject *args) {
11882 PyObject *resultobj = 0;
11883 PLINT arg1 ;
11884 PLINT arg2 ;
11885 PLINT arg3 ;
11886 int val1 ;
11887 int ecode1 = 0 ;
11888 int val2 ;
11889 int ecode2 = 0 ;
11890 int val3 ;
11891 int ecode3 = 0 ;
11892 PyObject *swig_obj[3] ;
11893
11894 (void)self;
11895 if (!SWIG_Python_UnpackTuple(args, "plsfam", 3, 3, swig_obj)) SWIG_fail;
11896 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11897 if (!SWIG_IsOK(ecode1)) {
11898 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11899 }
11900 arg1 = (PLINT)(val1);
11901 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11902 if (!SWIG_IsOK(ecode2)) {
11903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11904 }
11905 arg2 = (PLINT)(val2);
11906 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11907 if (!SWIG_IsOK(ecode3)) {
11908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11909 }
11910 arg3 = (PLINT)(val3);
11911 plsfam(arg1,arg2,arg3);
11912 resultobj = SWIG_Py_Void();
11913 return resultobj;
11914fail:
11915 return NULL;
11916}
11917
11918
11919SWIGINTERN PyObject *_wrap_plsfci(PyObject *self, PyObject *args) {
11920 PyObject *resultobj = 0;
11921 PLUNICODE arg1 ;
11922 unsigned int val1 ;
11923 int ecode1 = 0 ;
11924 PyObject *swig_obj[1] ;
11925
11926 (void)self;
11927 if (!args) SWIG_fail;
11928 swig_obj[0] = args;
11929 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11930 if (!SWIG_IsOK(ecode1)) {
11931 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11932 }
11933 arg1 = (PLUNICODE)(val1);
11934 plsfci(arg1);
11935 resultobj = SWIG_Py_Void();
11936 return resultobj;
11937fail:
11938 return NULL;
11939}
11940
11941
11942SWIGINTERN PyObject *_wrap_plsfnam(PyObject *self, PyObject *args) {
11943 PyObject *resultobj = 0;
11944 char *arg1 = (char *) 0 ;
11945 int res1 ;
11946 char *buf1 = 0 ;
11947 int alloc1 = 0 ;
11948 PyObject *swig_obj[1] ;
11949
11950 (void)self;
11951 if (!args) SWIG_fail;
11952 swig_obj[0] = args;
11953 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11954 if (!SWIG_IsOK(res1)) {
11955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11956 }
11957 arg1 = (char *)(buf1);
11958 plsfnam((char const *)arg1);
11959 resultobj = SWIG_Py_Void();
11960 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11961 return resultobj;
11962fail:
11963 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11964 return NULL;
11965}
11966
11967
11968SWIGINTERN PyObject *_wrap_plsfont(PyObject *self, PyObject *args) {
11969 PyObject *resultobj = 0;
11970 PLINT arg1 ;
11971 PLINT arg2 ;
11972 PLINT arg3 ;
11973 int val1 ;
11974 int ecode1 = 0 ;
11975 int val2 ;
11976 int ecode2 = 0 ;
11977 int val3 ;
11978 int ecode3 = 0 ;
11979 PyObject *swig_obj[3] ;
11980
11981 (void)self;
11982 if (!SWIG_Python_UnpackTuple(args, "plsfont", 3, 3, swig_obj)) SWIG_fail;
11983 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11984 if (!SWIG_IsOK(ecode1)) {
11985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11986 }
11987 arg1 = (PLINT)(val1);
11988 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11989 if (!SWIG_IsOK(ecode2)) {
11990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11991 }
11992 arg2 = (PLINT)(val2);
11993 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11994 if (!SWIG_IsOK(ecode3)) {
11995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11996 }
11997 arg3 = (PLINT)(val3);
11998 plsfont(arg1,arg2,arg3);
11999 resultobj = SWIG_Py_Void();
12000 return resultobj;
12001fail:
12002 return NULL;
12003}
12004
12005
12006SWIGINTERN PyObject *_wrap_plshades(PyObject *self, PyObject *args) {
12007 PyObject *resultobj = 0;
12008 PLFLT **arg1 = (PLFLT **) 0 ;
12009 PLINT arg2 ;
12010 PLINT arg3 ;
12011 defined_func arg4 = (defined_func) 0 ;
12012 PLFLT arg5 ;
12013 PLFLT arg6 ;
12014 PLFLT arg7 ;
12015 PLFLT arg8 ;
12016 PLFLT *arg9 = (PLFLT *) 0 ;
12017 PLINT arg10 ;
12018 PLFLT arg11 ;
12019 PLINT arg12 ;
12020 PLFLT arg13 ;
12021 fill_func arg14 = (fill_func) 0 ;
12022 PLBOOL arg15 ;
12023 pltr_func arg16 = (pltr_func) 0 ;
12024 PLPointer arg17 = (PLPointer) 0 ;
12025 PyArrayObject *tmp1 = NULL ;
12026 double val5 ;
12027 int ecode5 = 0 ;
12028 double val6 ;
12029 int ecode6 = 0 ;
12030 double val7 ;
12031 int ecode7 = 0 ;
12032 double val8 ;
12033 int ecode8 = 0 ;
12034 PyArrayObject *tmp9 = NULL ;
12035 double val11 ;
12036 int ecode11 = 0 ;
12037 int val12 ;
12038 int ecode12 = 0 ;
12039 double val13 ;
12040 int ecode13 = 0 ;
12041 int val15 ;
12042 int ecode15 = 0 ;
12043 PyObject *swig_obj[12] ;
12044
12045 {
12046 python_pltr = 0;
12047 arg16 = NULL;
12048 }
12049 {
12050 arg17 = NULL;
12051 }
12052 {
12053 arg4 = NULL;
12054 }
12055 {
12056 arg14 = plfill;
12057 }
12058 (void)self;
12059 if (!SWIG_Python_UnpackTuple(args, "plshades", 10, 12, swig_obj)) SWIG_fail;
12060 {
12061 int i, size;
12062 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12063 if ( tmp1 == NULL )
12064 return NULL;
12065 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12066 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12067 size = arg3;
12068 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12069 for ( i = 0; i < arg2; i++ )
12070 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12071 }
12072 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12073 if (!SWIG_IsOK(ecode5)) {
12074 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
12075 }
12076 arg5 = (PLFLT)(val5);
12077 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12078 if (!SWIG_IsOK(ecode6)) {
12079 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
12080 }
12081 arg6 = (PLFLT)(val6);
12082 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12083 if (!SWIG_IsOK(ecode7)) {
12084 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
12085 }
12086 arg7 = (PLFLT)(val7);
12087 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12088 if (!SWIG_IsOK(ecode8)) {
12089 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
12090 }
12091 arg8 = (PLFLT)(val8);
12092 {
12093 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
12094 if ( tmp9 == NULL )
12095 return NULL;
12096 arg10 = PyArray_DIMS( tmp9 )[0];
12097 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
12098 }
12099 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
12100 if (!SWIG_IsOK(ecode11)) {
12101 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
12102 }
12103 arg11 = (PLFLT)(val11);
12104 ecode12 = SWIG_AsVal_int(swig_obj[7], &val12);
12105 if (!SWIG_IsOK(ecode12)) {
12106 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
12107 }
12108 arg12 = (PLINT)(val12);
12109 ecode13 = SWIG_AsVal_double(swig_obj[8], &val13);
12110 if (!SWIG_IsOK(ecode13)) {
12111 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
12112 }
12113 arg13 = (PLFLT)(val13);
12114 ecode15 = SWIG_AsVal_int(swig_obj[9], &val15);
12115 if (!SWIG_IsOK(ecode15)) {
12116 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
12117 }
12118 arg15 = (PLBOOL)(val15);
12119 if (swig_obj[10]) {
12120 {
12121 // it must be a callable or None
12122 if ( swig_obj[10] == Py_None )
12123 {
12124 arg16 = NULL;
12125 }
12126 else
12127 {
12128 if ( !PyCallable_Check( (PyObject *) swig_obj[10] ) )
12129 {
12130 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12131 return NULL;
12132 }
12133 arg16 = marshal_pltr( swig_obj[10] );
12134 }
12135 }
12136 }
12137 if (swig_obj[11]) {
12138 {
12139 if ( swig_obj[11] == Py_None )
12140 arg17 = NULL;
12141 else
12142 {
12143 arg17 = marshal_PLPointer( swig_obj[11], 0 );
12144 }
12145 }
12146 }
12147 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
12148 resultobj = SWIG_Py_Void();
12149 {
12150 Py_CLEAR( tmp1 );
12151 free( arg1 );
12152 }
12153 {
12154 Py_CLEAR( tmp9 );
12155 }
12156 {
12157 cleanup_pltr();
12158 }
12159 {
12161 }
12162 return resultobj;
12163fail:
12164 {
12165 Py_CLEAR( tmp1 );
12166 free( arg1 );
12167 }
12168 {
12169 Py_CLEAR( tmp9 );
12170 }
12171 {
12172 cleanup_pltr();
12173 }
12174 {
12176 }
12177 return NULL;
12178}
12179
12180
12181SWIGINTERN PyObject *_wrap_plshade(PyObject *self, PyObject *args) {
12182 PyObject *resultobj = 0;
12183 PLFLT **arg1 = (PLFLT **) 0 ;
12184 PLINT arg2 ;
12185 PLINT arg3 ;
12186 defined_func arg4 = (defined_func) 0 ;
12187 PLFLT arg5 ;
12188 PLFLT arg6 ;
12189 PLFLT arg7 ;
12190 PLFLT arg8 ;
12191 PLFLT arg9 ;
12192 PLFLT arg10 ;
12193 PLINT arg11 ;
12194 PLFLT arg12 ;
12195 PLFLT arg13 ;
12196 PLINT arg14 ;
12197 PLFLT arg15 ;
12198 PLINT arg16 ;
12199 PLFLT arg17 ;
12200 fill_func arg18 = (fill_func) 0 ;
12201 PLBOOL arg19 ;
12202 pltr_func arg20 = (pltr_func) 0 ;
12203 PLPointer arg21 = (PLPointer) 0 ;
12204 PyArrayObject *tmp1 = NULL ;
12205 double val5 ;
12206 int ecode5 = 0 ;
12207 double val6 ;
12208 int ecode6 = 0 ;
12209 double val7 ;
12210 int ecode7 = 0 ;
12211 double val8 ;
12212 int ecode8 = 0 ;
12213 double val9 ;
12214 int ecode9 = 0 ;
12215 double val10 ;
12216 int ecode10 = 0 ;
12217 int val11 ;
12218 int ecode11 = 0 ;
12219 double val12 ;
12220 int ecode12 = 0 ;
12221 double val13 ;
12222 int ecode13 = 0 ;
12223 int val14 ;
12224 int ecode14 = 0 ;
12225 double val15 ;
12226 int ecode15 = 0 ;
12227 int val16 ;
12228 int ecode16 = 0 ;
12229 double val17 ;
12230 int ecode17 = 0 ;
12231 int val19 ;
12232 int ecode19 = 0 ;
12233 PyObject *swig_obj[17] ;
12234
12235 {
12236 python_pltr = 0;
12237 arg20 = NULL;
12238 }
12239 {
12240 arg21 = NULL;
12241 }
12242 {
12243 arg4 = NULL;
12244 }
12245 {
12246 arg18 = plfill;
12247 }
12248 (void)self;
12249 if (!SWIG_Python_UnpackTuple(args, "plshade", 15, 17, swig_obj)) SWIG_fail;
12250 {
12251 int i, size;
12252 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12253 if ( tmp1 == NULL )
12254 return NULL;
12255 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12256 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12257 size = arg3;
12258 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12259 for ( i = 0; i < arg2; i++ )
12260 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12261 }
12262 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12263 if (!SWIG_IsOK(ecode5)) {
12264 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12265 }
12266 arg5 = (PLFLT)(val5);
12267 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12268 if (!SWIG_IsOK(ecode6)) {
12269 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12270 }
12271 arg6 = (PLFLT)(val6);
12272 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12273 if (!SWIG_IsOK(ecode7)) {
12274 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12275 }
12276 arg7 = (PLFLT)(val7);
12277 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12278 if (!SWIG_IsOK(ecode8)) {
12279 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12280 }
12281 arg8 = (PLFLT)(val8);
12282 ecode9 = SWIG_AsVal_double(swig_obj[5], &val9);
12283 if (!SWIG_IsOK(ecode9)) {
12284 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12285 }
12286 arg9 = (PLFLT)(val9);
12287 ecode10 = SWIG_AsVal_double(swig_obj[6], &val10);
12288 if (!SWIG_IsOK(ecode10)) {
12289 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12290 }
12291 arg10 = (PLFLT)(val10);
12292 ecode11 = SWIG_AsVal_int(swig_obj[7], &val11);
12293 if (!SWIG_IsOK(ecode11)) {
12294 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12295 }
12296 arg11 = (PLINT)(val11);
12297 ecode12 = SWIG_AsVal_double(swig_obj[8], &val12);
12298 if (!SWIG_IsOK(ecode12)) {
12299 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12300 }
12301 arg12 = (PLFLT)(val12);
12302 ecode13 = SWIG_AsVal_double(swig_obj[9], &val13);
12303 if (!SWIG_IsOK(ecode13)) {
12304 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12305 }
12306 arg13 = (PLFLT)(val13);
12307 ecode14 = SWIG_AsVal_int(swig_obj[10], &val14);
12308 if (!SWIG_IsOK(ecode14)) {
12309 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12310 }
12311 arg14 = (PLINT)(val14);
12312 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
12313 if (!SWIG_IsOK(ecode15)) {
12314 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12315 }
12316 arg15 = (PLFLT)(val15);
12317 ecode16 = SWIG_AsVal_int(swig_obj[12], &val16);
12318 if (!SWIG_IsOK(ecode16)) {
12319 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12320 }
12321 arg16 = (PLINT)(val16);
12322 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
12323 if (!SWIG_IsOK(ecode17)) {
12324 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12325 }
12326 arg17 = (PLFLT)(val17);
12327 ecode19 = SWIG_AsVal_int(swig_obj[14], &val19);
12328 if (!SWIG_IsOK(ecode19)) {
12329 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12330 }
12331 arg19 = (PLBOOL)(val19);
12332 if (swig_obj[15]) {
12333 {
12334 // it must be a callable or None
12335 if ( swig_obj[15] == Py_None )
12336 {
12337 arg20 = NULL;
12338 }
12339 else
12340 {
12341 if ( !PyCallable_Check( (PyObject *) swig_obj[15] ) )
12342 {
12343 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12344 return NULL;
12345 }
12346 arg20 = marshal_pltr( swig_obj[15] );
12347 }
12348 }
12349 }
12350 if (swig_obj[16]) {
12351 {
12352 if ( swig_obj[16] == Py_None )
12353 arg21 = NULL;
12354 else
12355 {
12356 arg21 = marshal_PLPointer( swig_obj[16], 0 );
12357 }
12358 }
12359 }
12360 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12361 resultobj = SWIG_Py_Void();
12362 {
12363 Py_CLEAR( tmp1 );
12364 free( arg1 );
12365 }
12366 {
12367 cleanup_pltr();
12368 }
12369 {
12371 }
12372 return resultobj;
12373fail:
12374 {
12375 Py_CLEAR( tmp1 );
12376 free( arg1 );
12377 }
12378 {
12379 cleanup_pltr();
12380 }
12381 {
12383 }
12384 return NULL;
12385}
12386
12387
12388SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *self, PyObject *args) {
12389 PyObject *resultobj = 0;
12390 label_func arg1 = (label_func) 0 ;
12391 PLPointer arg2 = (PLPointer) 0 ;
12392 int res2 ;
12393 PyObject *swig_obj[2] ;
12394
12395 (void)self;
12396 if (!SWIG_Python_UnpackTuple(args, "plslabelfunc", 2, 2, swig_obj)) SWIG_fail;
12397 {
12398 // Release reference to previous function if applicable
12399 if ( python_label )
12400 {
12401 Py_CLEAR( python_label );
12402 python_label = 0;
12403 }
12404 // it must be a callable or None
12405 if ( swig_obj[0] == Py_None )
12406 {
12407 arg1 = NULL;
12408 }
12409 else
12410 {
12411 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12412 {
12413 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12414 return NULL;
12415 }
12416 // hold a reference to it
12417 Py_XINCREF( (PyObject *) swig_obj[0] );
12418 python_label = (PyObject *) swig_obj[0];
12419 // this function handles calling the python function
12420 arg1 = do_label_callback;
12421 }
12422 }
12423 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12424 if (!SWIG_IsOK(res2)) {
12425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12426 }
12427 plslabelfunc(arg1,arg2);
12428 resultobj = SWIG_Py_Void();
12429 return resultobj;
12430fail:
12431 return NULL;
12432}
12433
12434
12435SWIGINTERN PyObject *_wrap_plsmaj(PyObject *self, PyObject *args) {
12436 PyObject *resultobj = 0;
12437 PLFLT arg1 ;
12438 PLFLT arg2 ;
12439 double val1 ;
12440 int ecode1 = 0 ;
12441 double val2 ;
12442 int ecode2 = 0 ;
12443 PyObject *swig_obj[2] ;
12444
12445 (void)self;
12446 if (!SWIG_Python_UnpackTuple(args, "plsmaj", 2, 2, swig_obj)) SWIG_fail;
12447 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12448 if (!SWIG_IsOK(ecode1)) {
12449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12450 }
12451 arg1 = (PLFLT)(val1);
12452 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12453 if (!SWIG_IsOK(ecode2)) {
12454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12455 }
12456 arg2 = (PLFLT)(val2);
12457 plsmaj(arg1,arg2);
12458 resultobj = SWIG_Py_Void();
12459 return resultobj;
12460fail:
12461 return NULL;
12462}
12463
12464
12465SWIGINTERN PyObject *_wrap_plsmem(PyObject *self, PyObject *args) {
12466 PyObject *resultobj = 0;
12467 PLINT arg1 ;
12468 PLINT arg2 ;
12469 void *arg3 = (void *) 0 ;
12470 int val1 ;
12471 int ecode1 = 0 ;
12472 int val2 ;
12473 int ecode2 = 0 ;
12474 PyObject *swig_obj[3] ;
12475
12476 (void)self;
12477 if (!SWIG_Python_UnpackTuple(args, "plsmem", 3, 3, swig_obj)) SWIG_fail;
12478 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12479 if (!SWIG_IsOK(ecode1)) {
12480 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12481 }
12482 arg1 = (PLINT)(val1);
12483 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12484 if (!SWIG_IsOK(ecode2)) {
12485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12486 }
12487 arg2 = (PLINT)(val2);
12488 {
12489 int res; void *buf = 0;
12490#ifndef Py_LIMITED_API
12491 Py_buffer view;
12492 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12493#else
12494#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12495#pragma GCC diagnostic push
12496#pragma GCC diagnostic ignored "-Wdeprecated"
12497#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12498#elif defined(_MSC_VER)
12499#pragma warning(push)
12500#pragma warning(disable: 4996)
12501#endif
12502 Py_ssize_t size;
12503 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12504#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12505#pragma GCC diagnostic pop
12506#elif defined(_MSC_VER)
12507#pragma warning(pop)
12508#endif
12509#endif
12510 if (res < 0) {
12511 PyErr_Clear();
12512 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem)""'");
12513 }
12514#ifndef Py_LIMITED_API
12515 buf = view.buf;
12516 PyBuffer_Release(&view);
12517#endif
12518 arg3 = (void *) buf;
12519 }
12520 plsmem(arg1,arg2,arg3);
12521 resultobj = SWIG_Py_Void();
12522 return resultobj;
12523fail:
12524 return NULL;
12525}
12526
12527
12528SWIGINTERN PyObject *_wrap_plsmema(PyObject *self, PyObject *args) {
12529 PyObject *resultobj = 0;
12530 PLINT arg1 ;
12531 PLINT arg2 ;
12532 void *arg3 = (void *) 0 ;
12533 int val1 ;
12534 int ecode1 = 0 ;
12535 int val2 ;
12536 int ecode2 = 0 ;
12537 PyObject *swig_obj[3] ;
12538
12539 (void)self;
12540 if (!SWIG_Python_UnpackTuple(args, "plsmema", 3, 3, swig_obj)) SWIG_fail;
12541 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12542 if (!SWIG_IsOK(ecode1)) {
12543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12544 }
12545 arg1 = (PLINT)(val1);
12546 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12547 if (!SWIG_IsOK(ecode2)) {
12548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12549 }
12550 arg2 = (PLINT)(val2);
12551 {
12552 int res; void *buf = 0;
12553#ifndef Py_LIMITED_API
12554 Py_buffer view;
12555 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12556#else
12557#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12558#pragma GCC diagnostic push
12559#pragma GCC diagnostic ignored "-Wdeprecated"
12560#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12561#elif defined(_MSC_VER)
12562#pragma warning(push)
12563#pragma warning(disable: 4996)
12564#endif
12565 Py_ssize_t size;
12566 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12567#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12568#pragma GCC diagnostic pop
12569#elif defined(_MSC_VER)
12570#pragma warning(pop)
12571#endif
12572#endif
12573 if (res < 0) {
12574 PyErr_Clear();
12575 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem)""'");
12576 }
12577#ifndef Py_LIMITED_API
12578 buf = view.buf;
12579 PyBuffer_Release(&view);
12580#endif
12581 arg3 = (void *) buf;
12582 }
12583 plsmema(arg1,arg2,arg3);
12584 resultobj = SWIG_Py_Void();
12585 return resultobj;
12586fail:
12587 return NULL;
12588}
12589
12590
12591SWIGINTERN PyObject *_wrap_plsmin(PyObject *self, PyObject *args) {
12592 PyObject *resultobj = 0;
12593 PLFLT arg1 ;
12594 PLFLT arg2 ;
12595 double val1 ;
12596 int ecode1 = 0 ;
12597 double val2 ;
12598 int ecode2 = 0 ;
12599 PyObject *swig_obj[2] ;
12600
12601 (void)self;
12602 if (!SWIG_Python_UnpackTuple(args, "plsmin", 2, 2, swig_obj)) SWIG_fail;
12603 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12604 if (!SWIG_IsOK(ecode1)) {
12605 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12606 }
12607 arg1 = (PLFLT)(val1);
12608 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12609 if (!SWIG_IsOK(ecode2)) {
12610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12611 }
12612 arg2 = (PLFLT)(val2);
12613 plsmin(arg1,arg2);
12614 resultobj = SWIG_Py_Void();
12615 return resultobj;
12616fail:
12617 return NULL;
12618}
12619
12620
12621SWIGINTERN PyObject *_wrap_plsori(PyObject *self, PyObject *args) {
12622 PyObject *resultobj = 0;
12623 PLINT arg1 ;
12624 int val1 ;
12625 int ecode1 = 0 ;
12626 PyObject *swig_obj[1] ;
12627
12628 (void)self;
12629 if (!args) SWIG_fail;
12630 swig_obj[0] = args;
12631 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12632 if (!SWIG_IsOK(ecode1)) {
12633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12634 }
12635 arg1 = (PLINT)(val1);
12636 plsori(arg1);
12637 resultobj = SWIG_Py_Void();
12638 return resultobj;
12639fail:
12640 return NULL;
12641}
12642
12643
12644SWIGINTERN PyObject *_wrap_plspage(PyObject *self, PyObject *args) {
12645 PyObject *resultobj = 0;
12646 PLFLT arg1 ;
12647 PLFLT arg2 ;
12648 PLINT arg3 ;
12649 PLINT arg4 ;
12650 PLINT arg5 ;
12651 PLINT arg6 ;
12652 double val1 ;
12653 int ecode1 = 0 ;
12654 double val2 ;
12655 int ecode2 = 0 ;
12656 int val3 ;
12657 int ecode3 = 0 ;
12658 int val4 ;
12659 int ecode4 = 0 ;
12660 int val5 ;
12661 int ecode5 = 0 ;
12662 int val6 ;
12663 int ecode6 = 0 ;
12664 PyObject *swig_obj[6] ;
12665
12666 (void)self;
12667 if (!SWIG_Python_UnpackTuple(args, "plspage", 6, 6, swig_obj)) SWIG_fail;
12668 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12669 if (!SWIG_IsOK(ecode1)) {
12670 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12671 }
12672 arg1 = (PLFLT)(val1);
12673 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12674 if (!SWIG_IsOK(ecode2)) {
12675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12676 }
12677 arg2 = (PLFLT)(val2);
12678 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12679 if (!SWIG_IsOK(ecode3)) {
12680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12681 }
12682 arg3 = (PLINT)(val3);
12683 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
12684 if (!SWIG_IsOK(ecode4)) {
12685 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12686 }
12687 arg4 = (PLINT)(val4);
12688 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
12689 if (!SWIG_IsOK(ecode5)) {
12690 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12691 }
12692 arg5 = (PLINT)(val5);
12693 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
12694 if (!SWIG_IsOK(ecode6)) {
12695 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12696 }
12697 arg6 = (PLINT)(val6);
12698 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12699 resultobj = SWIG_Py_Void();
12700 return resultobj;
12701fail:
12702 return NULL;
12703}
12704
12705
12706SWIGINTERN PyObject *_wrap_plspal0(PyObject *self, PyObject *args) {
12707 PyObject *resultobj = 0;
12708 char *arg1 = (char *) 0 ;
12709 int res1 ;
12710 char *buf1 = 0 ;
12711 int alloc1 = 0 ;
12712 PyObject *swig_obj[1] ;
12713
12714 (void)self;
12715 if (!args) SWIG_fail;
12716 swig_obj[0] = args;
12717 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12718 if (!SWIG_IsOK(res1)) {
12719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12720 }
12721 arg1 = (char *)(buf1);
12722 plspal0((char const *)arg1);
12723 resultobj = SWIG_Py_Void();
12724 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12725 return resultobj;
12726fail:
12727 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12728 return NULL;
12729}
12730
12731
12732SWIGINTERN PyObject *_wrap_plspal1(PyObject *self, PyObject *args) {
12733 PyObject *resultobj = 0;
12734 char *arg1 = (char *) 0 ;
12735 PLBOOL arg2 ;
12736 int res1 ;
12737 char *buf1 = 0 ;
12738 int alloc1 = 0 ;
12739 int val2 ;
12740 int ecode2 = 0 ;
12741 PyObject *swig_obj[2] ;
12742
12743 (void)self;
12744 if (!SWIG_Python_UnpackTuple(args, "plspal1", 2, 2, swig_obj)) SWIG_fail;
12745 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12746 if (!SWIG_IsOK(res1)) {
12747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12748 }
12749 arg1 = (char *)(buf1);
12750 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12751 if (!SWIG_IsOK(ecode2)) {
12752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12753 }
12754 arg2 = (PLBOOL)(val2);
12755 plspal1((char const *)arg1,arg2);
12756 resultobj = SWIG_Py_Void();
12757 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12758 return resultobj;
12759fail:
12760 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12761 return NULL;
12762}
12763
12764
12765SWIGINTERN PyObject *_wrap_plspause(PyObject *self, PyObject *args) {
12766 PyObject *resultobj = 0;
12767 PLBOOL arg1 ;
12768 int val1 ;
12769 int ecode1 = 0 ;
12770 PyObject *swig_obj[1] ;
12771
12772 (void)self;
12773 if (!args) SWIG_fail;
12774 swig_obj[0] = args;
12775 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12776 if (!SWIG_IsOK(ecode1)) {
12777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12778 }
12779 arg1 = (PLBOOL)(val1);
12780 plspause(arg1);
12781 resultobj = SWIG_Py_Void();
12782 return resultobj;
12783fail:
12784 return NULL;
12785}
12786
12787
12788SWIGINTERN PyObject *_wrap_plsstrm(PyObject *self, PyObject *args) {
12789 PyObject *resultobj = 0;
12790 PLINT arg1 ;
12791 int val1 ;
12792 int ecode1 = 0 ;
12793 PyObject *swig_obj[1] ;
12794
12795 (void)self;
12796 if (!args) SWIG_fail;
12797 swig_obj[0] = args;
12798 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12799 if (!SWIG_IsOK(ecode1)) {
12800 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12801 }
12802 arg1 = (PLINT)(val1);
12803 plsstrm(arg1);
12804 resultobj = SWIG_Py_Void();
12805 return resultobj;
12806fail:
12807 return NULL;
12808}
12809
12810
12811SWIGINTERN PyObject *_wrap_plssub(PyObject *self, PyObject *args) {
12812 PyObject *resultobj = 0;
12813 PLINT arg1 ;
12814 PLINT arg2 ;
12815 int val1 ;
12816 int ecode1 = 0 ;
12817 int val2 ;
12818 int ecode2 = 0 ;
12819 PyObject *swig_obj[2] ;
12820
12821 (void)self;
12822 if (!SWIG_Python_UnpackTuple(args, "plssub", 2, 2, swig_obj)) SWIG_fail;
12823 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12824 if (!SWIG_IsOK(ecode1)) {
12825 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12826 }
12827 arg1 = (PLINT)(val1);
12828 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12829 if (!SWIG_IsOK(ecode2)) {
12830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12831 }
12832 arg2 = (PLINT)(val2);
12833 plssub(arg1,arg2);
12834 resultobj = SWIG_Py_Void();
12835 return resultobj;
12836fail:
12837 return NULL;
12838}
12839
12840
12841SWIGINTERN PyObject *_wrap_plssym(PyObject *self, PyObject *args) {
12842 PyObject *resultobj = 0;
12843 PLFLT arg1 ;
12844 PLFLT arg2 ;
12845 double val1 ;
12846 int ecode1 = 0 ;
12847 double val2 ;
12848 int ecode2 = 0 ;
12849 PyObject *swig_obj[2] ;
12850
12851 (void)self;
12852 if (!SWIG_Python_UnpackTuple(args, "plssym", 2, 2, swig_obj)) SWIG_fail;
12853 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12854 if (!SWIG_IsOK(ecode1)) {
12855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12856 }
12857 arg1 = (PLFLT)(val1);
12858 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12859 if (!SWIG_IsOK(ecode2)) {
12860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12861 }
12862 arg2 = (PLFLT)(val2);
12863 plssym(arg1,arg2);
12864 resultobj = SWIG_Py_Void();
12865 return resultobj;
12866fail:
12867 return NULL;
12868}
12869
12870
12871SWIGINTERN PyObject *_wrap_plstar(PyObject *self, PyObject *args) {
12872 PyObject *resultobj = 0;
12873 PLINT arg1 ;
12874 PLINT arg2 ;
12875 int val1 ;
12876 int ecode1 = 0 ;
12877 int val2 ;
12878 int ecode2 = 0 ;
12879 PyObject *swig_obj[2] ;
12880
12881 (void)self;
12882 if (!SWIG_Python_UnpackTuple(args, "plstar", 2, 2, swig_obj)) SWIG_fail;
12883 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12884 if (!SWIG_IsOK(ecode1)) {
12885 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12886 }
12887 arg1 = (PLINT)(val1);
12888 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12889 if (!SWIG_IsOK(ecode2)) {
12890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12891 }
12892 arg2 = (PLINT)(val2);
12893 plstar(arg1,arg2);
12894 resultobj = SWIG_Py_Void();
12895 return resultobj;
12896fail:
12897 return NULL;
12898}
12899
12900
12901SWIGINTERN PyObject *_wrap_plstart(PyObject *self, PyObject *args) {
12902 PyObject *resultobj = 0;
12903 char *arg1 = (char *) 0 ;
12904 PLINT arg2 ;
12905 PLINT arg3 ;
12906 int res1 ;
12907 char *buf1 = 0 ;
12908 int alloc1 = 0 ;
12909 int val2 ;
12910 int ecode2 = 0 ;
12911 int val3 ;
12912 int ecode3 = 0 ;
12913 PyObject *swig_obj[3] ;
12914
12915 (void)self;
12916 if (!SWIG_Python_UnpackTuple(args, "plstart", 3, 3, swig_obj)) SWIG_fail;
12917 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12918 if (!SWIG_IsOK(res1)) {
12919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12920 }
12921 arg1 = (char *)(buf1);
12922 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12923 if (!SWIG_IsOK(ecode2)) {
12924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12925 }
12926 arg2 = (PLINT)(val2);
12927 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12928 if (!SWIG_IsOK(ecode3)) {
12929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12930 }
12931 arg3 = (PLINT)(val3);
12932 plstart((char const *)arg1,arg2,arg3);
12933 resultobj = SWIG_Py_Void();
12934 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12935 return resultobj;
12936fail:
12937 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12938 return NULL;
12939}
12940
12941
12942SWIGINTERN PyObject *_wrap_plstransform(PyObject *self, PyObject *args) {
12943 PyObject *resultobj = 0;
12944 ct_func arg1 = (ct_func) 0 ;
12945 PLPointer arg2 = (PLPointer) 0 ;
12946 int res2 ;
12947 PyObject *swig_obj[2] ;
12948
12949 {
12950 python_ct = 0;
12951 arg1 = NULL;
12952 }
12953 (void)self;
12954 if (!SWIG_Python_UnpackTuple(args, "plstransform", 0, 2, swig_obj)) SWIG_fail;
12955 if (swig_obj[0]) {
12956 {
12957 if ( python_ct )
12958 cleanup_ct();
12959 // it must be a callable or none
12960 if ( swig_obj[0] == Py_None )
12961 {
12962 arg1 = NULL;
12963 }
12964 else
12965 {
12966 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12967 {
12968 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12969 return NULL;
12970 }
12971 arg1 = marshal_ct( swig_obj[0] );
12972 }
12973 }
12974 }
12975 if (swig_obj[1]) {
12976 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12977 if (!SWIG_IsOK(res2)) {
12978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12979 }
12980 }
12981 plstransform(arg1,arg2);
12982 resultobj = SWIG_Py_Void();
12983 return resultobj;
12984fail:
12985 return NULL;
12986}
12987
12988
12989SWIGINTERN PyObject *_wrap_plstring(PyObject *self, PyObject *args) {
12990 PyObject *resultobj = 0;
12991 PLINT arg1 ;
12992 PLFLT *arg2 = (PLFLT *) 0 ;
12993 PLFLT *arg3 = (PLFLT *) 0 ;
12994 char *arg4 = (char *) 0 ;
12995 PyArrayObject *tmp1 = NULL ;
12996 PyArrayObject *tmp3 = NULL ;
12997 int res4 ;
12998 char *buf4 = 0 ;
12999 int alloc4 = 0 ;
13000 PyObject *swig_obj[3] ;
13001
13002 (void)self;
13003 if (!SWIG_Python_UnpackTuple(args, "plstring", 3, 3, swig_obj)) SWIG_fail;
13004 {
13005 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13006 if ( tmp1 == NULL )
13007 return NULL;
13008 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13009 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13010 }
13011 {
13012 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13013 if ( tmp3 == NULL )
13014 return NULL;
13015 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13016 {
13017 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13018 return NULL;
13019 }
13020 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13021 }
13022 res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
13023 if (!SWIG_IsOK(res4)) {
13024 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
13025 }
13026 arg4 = (char *)(buf4);
13027 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
13028 resultobj = SWIG_Py_Void();
13029 {
13030 Py_CLEAR( tmp1 );
13031 }
13032 {
13033 Py_CLEAR( tmp3 );
13034 }
13035 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13036 return resultobj;
13037fail:
13038 {
13039 Py_CLEAR( tmp1 );
13040 }
13041 {
13042 Py_CLEAR( tmp3 );
13043 }
13044 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13045 return NULL;
13046}
13047
13048
13049SWIGINTERN PyObject *_wrap_plstring3(PyObject *self, PyObject *args) {
13050 PyObject *resultobj = 0;
13051 PLINT arg1 ;
13052 PLFLT *arg2 = (PLFLT *) 0 ;
13053 PLFLT *arg3 = (PLFLT *) 0 ;
13054 PLFLT *arg4 = (PLFLT *) 0 ;
13055 char *arg5 = (char *) 0 ;
13056 PyArrayObject *tmp1 = NULL ;
13057 PyArrayObject *tmp3 = NULL ;
13058 PyArrayObject *tmp4 = NULL ;
13059 int res5 ;
13060 char *buf5 = 0 ;
13061 int alloc5 = 0 ;
13062 PyObject *swig_obj[4] ;
13063
13064 (void)self;
13065 if (!SWIG_Python_UnpackTuple(args, "plstring3", 4, 4, swig_obj)) SWIG_fail;
13066 {
13067 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13068 if ( tmp1 == NULL )
13069 return NULL;
13070 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13071 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13072 }
13073 {
13074 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13075 if ( tmp3 == NULL )
13076 return NULL;
13077 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13078 {
13079 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13080 return NULL;
13081 }
13082 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13083 }
13084 {
13085 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
13086 if ( tmp4 == NULL )
13087 return NULL;
13088 if ( PyArray_DIMS( tmp4 )[0] != Alen )
13089 {
13090 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13091 return NULL;
13092 }
13093 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
13094 }
13095 res5 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf5, NULL, &alloc5);
13096 if (!SWIG_IsOK(res5)) {
13097 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
13098 }
13099 arg5 = (char *)(buf5);
13100 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
13101 resultobj = SWIG_Py_Void();
13102 {
13103 Py_CLEAR( tmp1 );
13104 }
13105 {
13106 Py_CLEAR( tmp3 );
13107 }
13108 {
13109 Py_CLEAR( tmp4 );
13110 }
13111 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13112 return resultobj;
13113fail:
13114 {
13115 Py_CLEAR( tmp1 );
13116 }
13117 {
13118 Py_CLEAR( tmp3 );
13119 }
13120 {
13121 Py_CLEAR( tmp4 );
13122 }
13123 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13124 return NULL;
13125}
13126
13127
13128SWIGINTERN PyObject *_wrap_plstripa(PyObject *self, PyObject *args) {
13129 PyObject *resultobj = 0;
13130 PLINT arg1 ;
13131 PLINT arg2 ;
13132 PLFLT arg3 ;
13133 PLFLT arg4 ;
13134 int val1 ;
13135 int ecode1 = 0 ;
13136 int val2 ;
13137 int ecode2 = 0 ;
13138 double val3 ;
13139 int ecode3 = 0 ;
13140 double val4 ;
13141 int ecode4 = 0 ;
13142 PyObject *swig_obj[4] ;
13143
13144 (void)self;
13145 if (!SWIG_Python_UnpackTuple(args, "plstripa", 4, 4, swig_obj)) SWIG_fail;
13146 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13147 if (!SWIG_IsOK(ecode1)) {
13148 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
13149 }
13150 arg1 = (PLINT)(val1);
13151 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13152 if (!SWIG_IsOK(ecode2)) {
13153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
13154 }
13155 arg2 = (PLINT)(val2);
13156 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13157 if (!SWIG_IsOK(ecode3)) {
13158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
13159 }
13160 arg3 = (PLFLT)(val3);
13161 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13162 if (!SWIG_IsOK(ecode4)) {
13163 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
13164 }
13165 arg4 = (PLFLT)(val4);
13166 plstripa(arg1,arg2,arg3,arg4);
13167 resultobj = SWIG_Py_Void();
13168 return resultobj;
13169fail:
13170 return NULL;
13171}
13172
13173
13174SWIGINTERN PyObject *_wrap_plstripc(PyObject *self, PyObject *args) {
13175 PyObject *resultobj = 0;
13176 PLINT *arg1 = (PLINT *) 0 ;
13177 char *arg2 = (char *) 0 ;
13178 char *arg3 = (char *) 0 ;
13179 PLFLT arg4 ;
13180 PLFLT arg5 ;
13181 PLFLT arg6 ;
13182 PLFLT arg7 ;
13183 PLFLT arg8 ;
13184 PLFLT arg9 ;
13185 PLFLT arg10 ;
13186 PLBOOL arg11 ;
13187 PLBOOL arg12 ;
13188 PLINT arg13 ;
13189 PLINT arg14 ;
13190 PLINT *arg15 = (PLINT *) 0 ;
13191 PLINT *arg16 = (PLINT *) 0 ;
13192 char **arg17 = (char **) (char **)0 ;
13193 char *arg18 = (char *) 0 ;
13194 char *arg19 = (char *) 0 ;
13195 char *arg20 = (char *) 0 ;
13196 PLINT temp1 ;
13197 int res1 = SWIG_TMPOBJ ;
13198 int res2 ;
13199 char *buf2 = 0 ;
13200 int alloc2 = 0 ;
13201 int res3 ;
13202 char *buf3 = 0 ;
13203 int alloc3 = 0 ;
13204 double val4 ;
13205 int ecode4 = 0 ;
13206 double val5 ;
13207 int ecode5 = 0 ;
13208 double val6 ;
13209 int ecode6 = 0 ;
13210 double val7 ;
13211 int ecode7 = 0 ;
13212 double val8 ;
13213 int ecode8 = 0 ;
13214 double val9 ;
13215 int ecode9 = 0 ;
13216 double val10 ;
13217 int ecode10 = 0 ;
13218 int val11 ;
13219 int ecode11 = 0 ;
13220 int val12 ;
13221 int ecode12 = 0 ;
13222 int val13 ;
13223 int ecode13 = 0 ;
13224 int val14 ;
13225 int ecode14 = 0 ;
13226 PyArrayObject *tmp15 = NULL ;
13227 PyArrayObject *tmp16 = NULL ;
13228 char **tmp17 = NULL ;
13229 int res18 ;
13230 char *buf18 = 0 ;
13231 int alloc18 = 0 ;
13232 int res19 ;
13233 char *buf19 = 0 ;
13234 int alloc19 = 0 ;
13235 int res20 ;
13236 char *buf20 = 0 ;
13237 int alloc20 = 0 ;
13238 PyObject *swig_obj[19] ;
13239
13240 arg1 = &temp1;
13241 (void)self;
13242 if (!SWIG_Python_UnpackTuple(args, "plstripc", 19, 19, swig_obj)) SWIG_fail;
13243 res2 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf2, NULL, &alloc2);
13244 if (!SWIG_IsOK(res2)) {
13245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13246 }
13247 arg2 = (char *)(buf2);
13248 res3 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf3, NULL, &alloc3);
13249 if (!SWIG_IsOK(res3)) {
13250 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13251 }
13252 arg3 = (char *)(buf3);
13253 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
13254 if (!SWIG_IsOK(ecode4)) {
13255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13256 }
13257 arg4 = (PLFLT)(val4);
13258 ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
13259 if (!SWIG_IsOK(ecode5)) {
13260 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13261 }
13262 arg5 = (PLFLT)(val5);
13263 ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
13264 if (!SWIG_IsOK(ecode6)) {
13265 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13266 }
13267 arg6 = (PLFLT)(val6);
13268 ecode7 = SWIG_AsVal_double(swig_obj[5], &val7);
13269 if (!SWIG_IsOK(ecode7)) {
13270 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13271 }
13272 arg7 = (PLFLT)(val7);
13273 ecode8 = SWIG_AsVal_double(swig_obj[6], &val8);
13274 if (!SWIG_IsOK(ecode8)) {
13275 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13276 }
13277 arg8 = (PLFLT)(val8);
13278 ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
13279 if (!SWIG_IsOK(ecode9)) {
13280 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13281 }
13282 arg9 = (PLFLT)(val9);
13283 ecode10 = SWIG_AsVal_double(swig_obj[8], &val10);
13284 if (!SWIG_IsOK(ecode10)) {
13285 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13286 }
13287 arg10 = (PLFLT)(val10);
13288 ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
13289 if (!SWIG_IsOK(ecode11)) {
13290 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13291 }
13292 arg11 = (PLBOOL)(val11);
13293 ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
13294 if (!SWIG_IsOK(ecode12)) {
13295 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13296 }
13297 arg12 = (PLBOOL)(val12);
13298 ecode13 = SWIG_AsVal_int(swig_obj[11], &val13);
13299 if (!SWIG_IsOK(ecode13)) {
13300 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13301 }
13302 arg13 = (PLINT)(val13);
13303 ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
13304 if (!SWIG_IsOK(ecode14)) {
13305 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13306 }
13307 arg14 = (PLINT)(val14);
13308 {
13309 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
13310 if ( tmp15 == NULL )
13311 return NULL;
13312 Alen = PyArray_DIMS( tmp15 )[0];
13313 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13314 }
13315 {
13316 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[14], NPY_PLINT, 1, 1 );
13317 if ( tmp16 == NULL )
13318 return NULL;
13319 if ( PyArray_DIMS( tmp16 )[0] != Alen )
13320 {
13321 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13322 return NULL;
13323 }
13324 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13325 }
13326 {
13327 int i;
13328 PyObject *elt, *unicode_string;
13329
13330 if ( !PySequence_Check( swig_obj[15] ) || PySequence_Size( swig_obj[15] ) != 4 )
13331 {
13332 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13333 return NULL;
13334 }
13335 if ( Alen != 4 )
13336 {
13337 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13338 return NULL;
13339 }
13340 tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13341 if ( tmp17 == NULL )
13342 return NULL;
13343 arg17 = tmp17;
13344 for ( i = 0; i < 4; i++ )
13345 {
13346 arg17[i] = NULL;
13347 elt = PySequence_Fast_GET_ITEM( swig_obj[15], i );
13348 if ( PyString_Check( elt ) )
13349 {
13350 arg17[i] = PyString_AsString( elt );
13351 }
13352 else if ( PyUnicode_Check( elt ) )
13353 {
13354 unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
13355 arg17[i] = PyBytes_AS_STRING( unicode_string );
13356 }
13357 if ( arg17[i] == NULL )
13358 {
13359 free( tmp17 );
13360 return NULL;
13361 }
13362 }
13363 }
13364 res18 = SWIG_AsCharPtrAndSize(swig_obj[16], &buf18, NULL, &alloc18);
13365 if (!SWIG_IsOK(res18)) {
13366 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13367 }
13368 arg18 = (char *)(buf18);
13369 res19 = SWIG_AsCharPtrAndSize(swig_obj[17], &buf19, NULL, &alloc19);
13370 if (!SWIG_IsOK(res19)) {
13371 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13372 }
13373 arg19 = (char *)(buf19);
13374 res20 = SWIG_AsCharPtrAndSize(swig_obj[18], &buf20, NULL, &alloc20);
13375 if (!SWIG_IsOK(res20)) {
13376 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13377 }
13378 arg20 = (char *)(buf20);
13379 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);
13380 resultobj = SWIG_Py_Void();
13381 if (SWIG_IsTmpObj(res1)) {
13382 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13383 } else {
13384 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13386 }
13387 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13388 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13389 {
13390 Py_CLEAR( tmp15 );
13391 }
13392 {
13393 Py_CLEAR( tmp16 );
13394 }
13395 {
13396 free( tmp17 );
13397 }
13398 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13399 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13400 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13401 return resultobj;
13402fail:
13403 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13404 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13405 {
13406 Py_CLEAR( tmp15 );
13407 }
13408 {
13409 Py_CLEAR( tmp16 );
13410 }
13411 {
13412 free( tmp17 );
13413 }
13414 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13415 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13416 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13417 return NULL;
13418}
13419
13420
13421SWIGINTERN PyObject *_wrap_plstripd(PyObject *self, PyObject *args) {
13422 PyObject *resultobj = 0;
13423 PLINT arg1 ;
13424 int val1 ;
13425 int ecode1 = 0 ;
13426 PyObject *swig_obj[1] ;
13427
13428 (void)self;
13429 if (!args) SWIG_fail;
13430 swig_obj[0] = args;
13431 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13432 if (!SWIG_IsOK(ecode1)) {
13433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13434 }
13435 arg1 = (PLINT)(val1);
13436 plstripd(arg1);
13437 resultobj = SWIG_Py_Void();
13438 return resultobj;
13439fail:
13440 return NULL;
13441}
13442
13443
13444SWIGINTERN PyObject *_wrap_plstyl(PyObject *self, PyObject *args) {
13445 PyObject *resultobj = 0;
13446 PLINT arg1 ;
13447 PLINT *arg2 = (PLINT *) 0 ;
13448 PLINT *arg3 = (PLINT *) 0 ;
13449 PyArrayObject *tmp1 = NULL ;
13450 PyArrayObject *tmp3 = NULL ;
13451 PyObject *swig_obj[2] ;
13452
13453 (void)self;
13454 if (!SWIG_Python_UnpackTuple(args, "plstyl", 2, 2, swig_obj)) SWIG_fail;
13455 {
13456 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
13457 if ( tmp1 == NULL )
13458 return NULL;
13459 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13460 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13461 }
13462 {
13463 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
13464 if ( tmp3 == NULL )
13465 return NULL;
13466 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13467 {
13468 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13469 return NULL;
13470 }
13471 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13472 }
13473 plstyl(arg1,(int const *)arg2,(int const *)arg3);
13474 resultobj = SWIG_Py_Void();
13475 {
13476 Py_CLEAR( tmp1 );
13477 }
13478 {
13479 Py_CLEAR( tmp3 );
13480 }
13481 return resultobj;
13482fail:
13483 {
13484 Py_CLEAR( tmp1 );
13485 }
13486 {
13487 Py_CLEAR( tmp3 );
13488 }
13489 return NULL;
13490}
13491
13492
13493SWIGINTERN PyObject *_wrap_plsvect(PyObject *self, PyObject *args) {
13494 PyObject *resultobj = 0;
13495 PLFLT *arg1 = (PLFLT *) 0 ;
13496 PLFLT *arg2 = (PLFLT *) 0 ;
13497 PLINT arg3 ;
13498 PLBOOL arg4 ;
13499 PyArrayObject *tmp1 = NULL ;
13500 PyArrayObject *tmp2 = NULL ;
13501 int val4 ;
13502 int ecode4 = 0 ;
13503 PyObject *swig_obj[3] ;
13504
13505 (void)self;
13506 if (!SWIG_Python_UnpackTuple(args, "plsvect", 3, 3, swig_obj)) SWIG_fail;
13507 {
13508 if ( swig_obj[0] != Py_None )
13509 {
13510 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13511 if ( tmp1 == NULL )
13512 return NULL;
13513 Alen = PyArray_DIMS( tmp1 )[0];
13514 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13515 }
13516 else
13517 {
13518 arg1 = NULL;
13519 Alen = 0;
13520 }
13521 }
13522 {
13523 if ( swig_obj[1] != Py_None )
13524 {
13525 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13526 if ( tmp2 == NULL )
13527 return NULL;
13528 if ( PyArray_DIMS( tmp2 )[0] != Alen )
13529 {
13530 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13531 return NULL;
13532 }
13533 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13534 arg3 = PyArray_DIMS( tmp2 )[0];
13535 }
13536 else
13537 {
13538 arg2 = NULL;
13539 arg3 = 0;
13540 }
13541 }
13542 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13543 if (!SWIG_IsOK(ecode4)) {
13544 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13545 }
13546 arg4 = (PLBOOL)(val4);
13547 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13548 resultobj = SWIG_Py_Void();
13549 {
13550 Py_CLEAR( tmp1 );
13551 }
13552 {
13553 Py_CLEAR( tmp2 );
13554 }
13555 return resultobj;
13556fail:
13557 {
13558 Py_CLEAR( tmp1 );
13559 }
13560 {
13561 Py_CLEAR( tmp2 );
13562 }
13563 return NULL;
13564}
13565
13566
13567SWIGINTERN PyObject *_wrap_plsvpa(PyObject *self, PyObject *args) {
13568 PyObject *resultobj = 0;
13569 PLFLT arg1 ;
13570 PLFLT arg2 ;
13571 PLFLT arg3 ;
13572 PLFLT arg4 ;
13573 double val1 ;
13574 int ecode1 = 0 ;
13575 double val2 ;
13576 int ecode2 = 0 ;
13577 double val3 ;
13578 int ecode3 = 0 ;
13579 double val4 ;
13580 int ecode4 = 0 ;
13581 PyObject *swig_obj[4] ;
13582
13583 (void)self;
13584 if (!SWIG_Python_UnpackTuple(args, "plsvpa", 4, 4, swig_obj)) SWIG_fail;
13585 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13586 if (!SWIG_IsOK(ecode1)) {
13587 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13588 }
13589 arg1 = (PLFLT)(val1);
13590 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13591 if (!SWIG_IsOK(ecode2)) {
13592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13593 }
13594 arg2 = (PLFLT)(val2);
13595 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13596 if (!SWIG_IsOK(ecode3)) {
13597 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13598 }
13599 arg3 = (PLFLT)(val3);
13600 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13601 if (!SWIG_IsOK(ecode4)) {
13602 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13603 }
13604 arg4 = (PLFLT)(val4);
13605 plsvpa(arg1,arg2,arg3,arg4);
13606 resultobj = SWIG_Py_Void();
13607 return resultobj;
13608fail:
13609 return NULL;
13610}
13611
13612
13613SWIGINTERN PyObject *_wrap_plsxax(PyObject *self, PyObject *args) {
13614 PyObject *resultobj = 0;
13615 PLINT arg1 ;
13616 PLINT arg2 ;
13617 int val1 ;
13618 int ecode1 = 0 ;
13619 int val2 ;
13620 int ecode2 = 0 ;
13621 PyObject *swig_obj[2] ;
13622
13623 (void)self;
13624 if (!SWIG_Python_UnpackTuple(args, "plsxax", 2, 2, swig_obj)) SWIG_fail;
13625 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13626 if (!SWIG_IsOK(ecode1)) {
13627 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13628 }
13629 arg1 = (PLINT)(val1);
13630 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13631 if (!SWIG_IsOK(ecode2)) {
13632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13633 }
13634 arg2 = (PLINT)(val2);
13635 plsxax(arg1,arg2);
13636 resultobj = SWIG_Py_Void();
13637 return resultobj;
13638fail:
13639 return NULL;
13640}
13641
13642
13643SWIGINTERN PyObject *_wrap_plsyax(PyObject *self, PyObject *args) {
13644 PyObject *resultobj = 0;
13645 PLINT arg1 ;
13646 PLINT arg2 ;
13647 int val1 ;
13648 int ecode1 = 0 ;
13649 int val2 ;
13650 int ecode2 = 0 ;
13651 PyObject *swig_obj[2] ;
13652
13653 (void)self;
13654 if (!SWIG_Python_UnpackTuple(args, "plsyax", 2, 2, swig_obj)) SWIG_fail;
13655 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13656 if (!SWIG_IsOK(ecode1)) {
13657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13658 }
13659 arg1 = (PLINT)(val1);
13660 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13661 if (!SWIG_IsOK(ecode2)) {
13662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13663 }
13664 arg2 = (PLINT)(val2);
13665 plsyax(arg1,arg2);
13666 resultobj = SWIG_Py_Void();
13667 return resultobj;
13668fail:
13669 return NULL;
13670}
13671
13672
13673SWIGINTERN PyObject *_wrap_plsym(PyObject *self, PyObject *args) {
13674 PyObject *resultobj = 0;
13675 PLINT arg1 ;
13676 PLFLT *arg2 = (PLFLT *) 0 ;
13677 PLFLT *arg3 = (PLFLT *) 0 ;
13678 PLINT arg4 ;
13679 PyArrayObject *tmp1 = NULL ;
13680 PyArrayObject *tmp3 = NULL ;
13681 int val4 ;
13682 int ecode4 = 0 ;
13683 PyObject *swig_obj[3] ;
13684
13685 (void)self;
13686 if (!SWIG_Python_UnpackTuple(args, "plsym", 3, 3, swig_obj)) SWIG_fail;
13687 {
13688 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13689 if ( tmp1 == NULL )
13690 return NULL;
13691 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13692 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13693 }
13694 {
13695 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13696 if ( tmp3 == NULL )
13697 return NULL;
13698 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13699 {
13700 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13701 return NULL;
13702 }
13703 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13704 }
13705 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13706 if (!SWIG_IsOK(ecode4)) {
13707 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13708 }
13709 arg4 = (PLINT)(val4);
13710 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13711 resultobj = SWIG_Py_Void();
13712 {
13713 Py_CLEAR( tmp1 );
13714 }
13715 {
13716 Py_CLEAR( tmp3 );
13717 }
13718 return resultobj;
13719fail:
13720 {
13721 Py_CLEAR( tmp1 );
13722 }
13723 {
13724 Py_CLEAR( tmp3 );
13725 }
13726 return NULL;
13727}
13728
13729
13730SWIGINTERN PyObject *_wrap_plszax(PyObject *self, PyObject *args) {
13731 PyObject *resultobj = 0;
13732 PLINT arg1 ;
13733 PLINT arg2 ;
13734 int val1 ;
13735 int ecode1 = 0 ;
13736 int val2 ;
13737 int ecode2 = 0 ;
13738 PyObject *swig_obj[2] ;
13739
13740 (void)self;
13741 if (!SWIG_Python_UnpackTuple(args, "plszax", 2, 2, swig_obj)) SWIG_fail;
13742 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13743 if (!SWIG_IsOK(ecode1)) {
13744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13745 }
13746 arg1 = (PLINT)(val1);
13747 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13748 if (!SWIG_IsOK(ecode2)) {
13749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13750 }
13751 arg2 = (PLINT)(val2);
13752 plszax(arg1,arg2);
13753 resultobj = SWIG_Py_Void();
13754 return resultobj;
13755fail:
13756 return NULL;
13757}
13758
13759
13760SWIGINTERN PyObject *_wrap_pltext(PyObject *self, PyObject *args) {
13761 PyObject *resultobj = 0;
13762
13763 (void)self;
13764 if (!SWIG_Python_UnpackTuple(args, "pltext", 0, 0, 0)) SWIG_fail;
13765 pltext();
13766 resultobj = SWIG_Py_Void();
13767 return resultobj;
13768fail:
13769 return NULL;
13770}
13771
13772
13773SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *self, PyObject *args) {
13774 PyObject *resultobj = 0;
13775 char *arg1 = (char *) 0 ;
13776 int res1 ;
13777 char *buf1 = 0 ;
13778 int alloc1 = 0 ;
13779 PyObject *swig_obj[1] ;
13780
13781 (void)self;
13782 if (!args) SWIG_fail;
13783 swig_obj[0] = args;
13784 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13785 if (!SWIG_IsOK(res1)) {
13786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13787 }
13788 arg1 = (char *)(buf1);
13789 pltimefmt((char const *)arg1);
13790 resultobj = SWIG_Py_Void();
13791 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13792 return resultobj;
13793fail:
13794 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13795 return NULL;
13796}
13797
13798
13799SWIGINTERN PyObject *_wrap_plvasp(PyObject *self, PyObject *args) {
13800 PyObject *resultobj = 0;
13801 PLFLT arg1 ;
13802 double val1 ;
13803 int ecode1 = 0 ;
13804 PyObject *swig_obj[1] ;
13805
13806 (void)self;
13807 if (!args) SWIG_fail;
13808 swig_obj[0] = args;
13809 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13810 if (!SWIG_IsOK(ecode1)) {
13811 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13812 }
13813 arg1 = (PLFLT)(val1);
13814 plvasp(arg1);
13815 resultobj = SWIG_Py_Void();
13816 return resultobj;
13817fail:
13818 return NULL;
13819}
13820
13821
13822SWIGINTERN PyObject *_wrap_plvect(PyObject *self, PyObject *args) {
13823 PyObject *resultobj = 0;
13824 PLFLT **arg1 = (PLFLT **) 0 ;
13825 PLFLT **arg2 = (PLFLT **) 0 ;
13826 PLINT arg3 ;
13827 PLINT arg4 ;
13828 PLFLT arg5 ;
13829 pltr_func arg6 = (pltr_func) 0 ;
13830 PLPointer arg7 = (PLPointer) 0 ;
13831 PyArrayObject *tmp1 = NULL ;
13832 PyArrayObject *tmp2 = NULL ;
13833 double val5 ;
13834 int ecode5 = 0 ;
13835 PyObject *swig_obj[5] ;
13836
13837 {
13838 python_pltr = 0;
13839 arg6 = NULL;
13840 }
13841 {
13842 arg7 = NULL;
13843 }
13844 (void)self;
13845 if (!SWIG_Python_UnpackTuple(args, "plvect", 3, 5, swig_obj)) SWIG_fail;
13846 {
13847 int i, size;
13848 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
13849 if ( tmp1 == NULL )
13850 return NULL;
13851 Xlen = PyArray_DIMS( tmp1 )[0];
13852 Ylen = PyArray_DIMS( tmp1 )[1];
13853 size = Ylen;
13854 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13855 for ( i = 0; i < Xlen; i++ )
13856 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13857 }
13858 {
13859 int i, size;
13860 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 2, 2 );
13861 if ( tmp2 == NULL )
13862 return NULL;
13863 if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13864 {
13865 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13866 return NULL;
13867 }
13868 arg3 = PyArray_DIMS( tmp2 )[0];
13869 arg4 = PyArray_DIMS( tmp2 )[1];
13870 size = arg4;
13871 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13872 for ( i = 0; i < arg3; i++ )
13873 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13874 }
13875 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
13876 if (!SWIG_IsOK(ecode5)) {
13877 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13878 }
13879 arg5 = (PLFLT)(val5);
13880 if (swig_obj[3]) {
13881 {
13882 // it must be a callable or None
13883 if ( swig_obj[3] == Py_None )
13884 {
13885 arg6 = NULL;
13886 }
13887 else
13888 {
13889 if ( !PyCallable_Check( (PyObject *) swig_obj[3] ) )
13890 {
13891 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13892 return NULL;
13893 }
13894 arg6 = marshal_pltr( swig_obj[3] );
13895 }
13896 }
13897 }
13898 if (swig_obj[4]) {
13899 {
13900 if ( swig_obj[4] == Py_None )
13901 arg7 = NULL;
13902 else
13903 {
13904 arg7 = marshal_PLPointer( swig_obj[4], 0 );
13905 }
13906 }
13907 }
13908 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13909 resultobj = SWIG_Py_Void();
13910 {
13911 Py_CLEAR( tmp1 );
13912 free( arg1 );
13913 }
13914 {
13915 Py_CLEAR( tmp2 );
13916 free( arg2 );
13917 }
13918 {
13919 cleanup_pltr();
13920 }
13921 {
13923 }
13924 return resultobj;
13925fail:
13926 {
13927 Py_CLEAR( tmp1 );
13928 free( arg1 );
13929 }
13930 {
13931 Py_CLEAR( tmp2 );
13932 free( arg2 );
13933 }
13934 {
13935 cleanup_pltr();
13936 }
13937 {
13939 }
13940 return NULL;
13941}
13942
13943
13944SWIGINTERN PyObject *_wrap_plvpas(PyObject *self, PyObject *args) {
13945 PyObject *resultobj = 0;
13946 PLFLT arg1 ;
13947 PLFLT arg2 ;
13948 PLFLT arg3 ;
13949 PLFLT arg4 ;
13950 PLFLT arg5 ;
13951 double val1 ;
13952 int ecode1 = 0 ;
13953 double val2 ;
13954 int ecode2 = 0 ;
13955 double val3 ;
13956 int ecode3 = 0 ;
13957 double val4 ;
13958 int ecode4 = 0 ;
13959 double val5 ;
13960 int ecode5 = 0 ;
13961 PyObject *swig_obj[5] ;
13962
13963 (void)self;
13964 if (!SWIG_Python_UnpackTuple(args, "plvpas", 5, 5, swig_obj)) SWIG_fail;
13965 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13966 if (!SWIG_IsOK(ecode1)) {
13967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13968 }
13969 arg1 = (PLFLT)(val1);
13970 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13971 if (!SWIG_IsOK(ecode2)) {
13972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13973 }
13974 arg2 = (PLFLT)(val2);
13975 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13976 if (!SWIG_IsOK(ecode3)) {
13977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13978 }
13979 arg3 = (PLFLT)(val3);
13980 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13981 if (!SWIG_IsOK(ecode4)) {
13982 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13983 }
13984 arg4 = (PLFLT)(val4);
13985 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13986 if (!SWIG_IsOK(ecode5)) {
13987 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13988 }
13989 arg5 = (PLFLT)(val5);
13990 plvpas(arg1,arg2,arg3,arg4,arg5);
13991 resultobj = SWIG_Py_Void();
13992 return resultobj;
13993fail:
13994 return NULL;
13995}
13996
13997
13998SWIGINTERN PyObject *_wrap_plvpor(PyObject *self, PyObject *args) {
13999 PyObject *resultobj = 0;
14000 PLFLT arg1 ;
14001 PLFLT arg2 ;
14002 PLFLT arg3 ;
14003 PLFLT arg4 ;
14004 double val1 ;
14005 int ecode1 = 0 ;
14006 double val2 ;
14007 int ecode2 = 0 ;
14008 double val3 ;
14009 int ecode3 = 0 ;
14010 double val4 ;
14011 int ecode4 = 0 ;
14012 PyObject *swig_obj[4] ;
14013
14014 (void)self;
14015 if (!SWIG_Python_UnpackTuple(args, "plvpor", 4, 4, swig_obj)) SWIG_fail;
14016 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14017 if (!SWIG_IsOK(ecode1)) {
14018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
14019 }
14020 arg1 = (PLFLT)(val1);
14021 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14022 if (!SWIG_IsOK(ecode2)) {
14023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
14024 }
14025 arg2 = (PLFLT)(val2);
14026 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14027 if (!SWIG_IsOK(ecode3)) {
14028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
14029 }
14030 arg3 = (PLFLT)(val3);
14031 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14032 if (!SWIG_IsOK(ecode4)) {
14033 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
14034 }
14035 arg4 = (PLFLT)(val4);
14036 plvpor(arg1,arg2,arg3,arg4);
14037 resultobj = SWIG_Py_Void();
14038 return resultobj;
14039fail:
14040 return NULL;
14041}
14042
14043
14044SWIGINTERN PyObject *_wrap_plvsta(PyObject *self, PyObject *args) {
14045 PyObject *resultobj = 0;
14046
14047 (void)self;
14048 if (!SWIG_Python_UnpackTuple(args, "plvsta", 0, 0, 0)) SWIG_fail;
14049 plvsta();
14050 resultobj = SWIG_Py_Void();
14051 return resultobj;
14052fail:
14053 return NULL;
14054}
14055
14056
14057SWIGINTERN PyObject *_wrap_plw3d(PyObject *self, PyObject *args) {
14058 PyObject *resultobj = 0;
14059 PLFLT arg1 ;
14060 PLFLT arg2 ;
14061 PLFLT arg3 ;
14062 PLFLT arg4 ;
14063 PLFLT arg5 ;
14064 PLFLT arg6 ;
14065 PLFLT arg7 ;
14066 PLFLT arg8 ;
14067 PLFLT arg9 ;
14068 PLFLT arg10 ;
14069 PLFLT arg11 ;
14070 double val1 ;
14071 int ecode1 = 0 ;
14072 double val2 ;
14073 int ecode2 = 0 ;
14074 double val3 ;
14075 int ecode3 = 0 ;
14076 double val4 ;
14077 int ecode4 = 0 ;
14078 double val5 ;
14079 int ecode5 = 0 ;
14080 double val6 ;
14081 int ecode6 = 0 ;
14082 double val7 ;
14083 int ecode7 = 0 ;
14084 double val8 ;
14085 int ecode8 = 0 ;
14086 double val9 ;
14087 int ecode9 = 0 ;
14088 double val10 ;
14089 int ecode10 = 0 ;
14090 double val11 ;
14091 int ecode11 = 0 ;
14092 PyObject *swig_obj[11] ;
14093
14094 (void)self;
14095 if (!SWIG_Python_UnpackTuple(args, "plw3d", 11, 11, swig_obj)) SWIG_fail;
14096 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14097 if (!SWIG_IsOK(ecode1)) {
14098 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
14099 }
14100 arg1 = (PLFLT)(val1);
14101 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14102 if (!SWIG_IsOK(ecode2)) {
14103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
14104 }
14105 arg2 = (PLFLT)(val2);
14106 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14107 if (!SWIG_IsOK(ecode3)) {
14108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
14109 }
14110 arg3 = (PLFLT)(val3);
14111 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14112 if (!SWIG_IsOK(ecode4)) {
14113 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
14114 }
14115 arg4 = (PLFLT)(val4);
14116 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14117 if (!SWIG_IsOK(ecode5)) {
14118 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
14119 }
14120 arg5 = (PLFLT)(val5);
14121 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14122 if (!SWIG_IsOK(ecode6)) {
14123 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
14124 }
14125 arg6 = (PLFLT)(val6);
14126 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14127 if (!SWIG_IsOK(ecode7)) {
14128 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
14129 }
14130 arg7 = (PLFLT)(val7);
14131 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14132 if (!SWIG_IsOK(ecode8)) {
14133 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
14134 }
14135 arg8 = (PLFLT)(val8);
14136 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14137 if (!SWIG_IsOK(ecode9)) {
14138 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
14139 }
14140 arg9 = (PLFLT)(val9);
14141 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14142 if (!SWIG_IsOK(ecode10)) {
14143 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
14144 }
14145 arg10 = (PLFLT)(val10);
14146 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
14147 if (!SWIG_IsOK(ecode11)) {
14148 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
14149 }
14150 arg11 = (PLFLT)(val11);
14151 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14152 resultobj = SWIG_Py_Void();
14153 return resultobj;
14154fail:
14155 return NULL;
14156}
14157
14158
14159SWIGINTERN PyObject *_wrap_plwidth(PyObject *self, PyObject *args) {
14160 PyObject *resultobj = 0;
14161 PLFLT arg1 ;
14162 double val1 ;
14163 int ecode1 = 0 ;
14164 PyObject *swig_obj[1] ;
14165
14166 (void)self;
14167 if (!args) SWIG_fail;
14168 swig_obj[0] = args;
14169 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14170 if (!SWIG_IsOK(ecode1)) {
14171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
14172 }
14173 arg1 = (PLFLT)(val1);
14174 plwidth(arg1);
14175 resultobj = SWIG_Py_Void();
14176 return resultobj;
14177fail:
14178 return NULL;
14179}
14180
14181
14182SWIGINTERN PyObject *_wrap_plwind(PyObject *self, PyObject *args) {
14183 PyObject *resultobj = 0;
14184 PLFLT arg1 ;
14185 PLFLT arg2 ;
14186 PLFLT arg3 ;
14187 PLFLT arg4 ;
14188 double val1 ;
14189 int ecode1 = 0 ;
14190 double val2 ;
14191 int ecode2 = 0 ;
14192 double val3 ;
14193 int ecode3 = 0 ;
14194 double val4 ;
14195 int ecode4 = 0 ;
14196 PyObject *swig_obj[4] ;
14197
14198 (void)self;
14199 if (!SWIG_Python_UnpackTuple(args, "plwind", 4, 4, swig_obj)) SWIG_fail;
14200 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14201 if (!SWIG_IsOK(ecode1)) {
14202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14203 }
14204 arg1 = (PLFLT)(val1);
14205 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14206 if (!SWIG_IsOK(ecode2)) {
14207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14208 }
14209 arg2 = (PLFLT)(val2);
14210 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14211 if (!SWIG_IsOK(ecode3)) {
14212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14213 }
14214 arg3 = (PLFLT)(val3);
14215 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14216 if (!SWIG_IsOK(ecode4)) {
14217 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14218 }
14219 arg4 = (PLFLT)(val4);
14220 plwind(arg1,arg2,arg3,arg4);
14221 resultobj = SWIG_Py_Void();
14222 return resultobj;
14223fail:
14224 return NULL;
14225}
14226
14227
14228SWIGINTERN PyObject *_wrap_plxormod(PyObject *self, PyObject *args) {
14229 PyObject *resultobj = 0;
14230 PLBOOL arg1 ;
14231 PLBOOL *arg2 = (PLBOOL *) 0 ;
14232 int val1 ;
14233 int ecode1 = 0 ;
14234 PLBOOL temp2 ;
14235 int res2 = SWIG_TMPOBJ ;
14236 PyObject *swig_obj[1] ;
14237
14238 arg2 = &temp2;
14239 (void)self;
14240 if (!args) SWIG_fail;
14241 swig_obj[0] = args;
14242 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
14243 if (!SWIG_IsOK(ecode1)) {
14244 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14245 }
14246 arg1 = (PLBOOL)(val1);
14247 plxormod(arg1,arg2);
14248 resultobj = SWIG_Py_Void();
14249 if (SWIG_IsTmpObj(res2)) {
14250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14251 } else {
14252 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14254 }
14255 return resultobj;
14256fail:
14257 return NULL;
14258}
14259
14260
14261SWIGINTERN PyObject *_wrap_plmap(PyObject *self, PyObject *args) {
14262 PyObject *resultobj = 0;
14263 mapform_func arg1 = (mapform_func) 0 ;
14264 char *arg2 = (char *) 0 ;
14265 PLFLT arg3 ;
14266 PLFLT arg4 ;
14267 PLFLT arg5 ;
14268 PLFLT arg6 ;
14269 int res2 ;
14270 char *buf2 = 0 ;
14271 int alloc2 = 0 ;
14272 double val3 ;
14273 int ecode3 = 0 ;
14274 double val4 ;
14275 int ecode4 = 0 ;
14276 double val5 ;
14277 int ecode5 = 0 ;
14278 double val6 ;
14279 int ecode6 = 0 ;
14280 PyObject *swig_obj[6] ;
14281
14282 (void)self;
14283 if (!SWIG_Python_UnpackTuple(args, "plmap", 6, 6, swig_obj)) SWIG_fail;
14284 {
14285 // it must be a callable or none
14286 if ( swig_obj[0] == Py_None )
14287 {
14288 arg1 = NULL;
14289 }
14290 else
14291 {
14292 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14293 {
14294 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14295 return NULL;
14296 }
14297 arg1 = marshal_mapform( swig_obj[0] );
14298 }
14299 }
14300 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14301 if (!SWIG_IsOK(res2)) {
14302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14303 }
14304 arg2 = (char *)(buf2);
14305 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14306 if (!SWIG_IsOK(ecode3)) {
14307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14308 }
14309 arg3 = (PLFLT)(val3);
14310 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14311 if (!SWIG_IsOK(ecode4)) {
14312 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14313 }
14314 arg4 = (PLFLT)(val4);
14315 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14316 if (!SWIG_IsOK(ecode5)) {
14317 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14318 }
14319 arg5 = (PLFLT)(val5);
14320 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14321 if (!SWIG_IsOK(ecode6)) {
14322 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14323 }
14324 arg6 = (PLFLT)(val6);
14325 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14326 resultobj = SWIG_Py_Void();
14327 {
14329 }
14330 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14331 return resultobj;
14332fail:
14333 {
14335 }
14336 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14337 return NULL;
14338}
14339
14340
14341SWIGINTERN PyObject *_wrap_plmapline(PyObject *self, PyObject *args) {
14342 PyObject *resultobj = 0;
14343 mapform_func arg1 = (mapform_func) 0 ;
14344 char *arg2 = (char *) 0 ;
14345 PLFLT arg3 ;
14346 PLFLT arg4 ;
14347 PLFLT arg5 ;
14348 PLFLT arg6 ;
14349 PLINT *arg7 = (PLINT *) 0 ;
14350 PLINT arg8 ;
14351 int res2 ;
14352 char *buf2 = 0 ;
14353 int alloc2 = 0 ;
14354 double val3 ;
14355 int ecode3 = 0 ;
14356 double val4 ;
14357 int ecode4 = 0 ;
14358 double val5 ;
14359 int ecode5 = 0 ;
14360 double val6 ;
14361 int ecode6 = 0 ;
14362 PyArrayObject *tmp7 = NULL ;
14363 PyObject *swig_obj[7] ;
14364
14365 (void)self;
14366 if (!SWIG_Python_UnpackTuple(args, "plmapline", 7, 7, swig_obj)) SWIG_fail;
14367 {
14368 // it must be a callable or none
14369 if ( swig_obj[0] == Py_None )
14370 {
14371 arg1 = NULL;
14372 }
14373 else
14374 {
14375 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14376 {
14377 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14378 return NULL;
14379 }
14380 arg1 = marshal_mapform( swig_obj[0] );
14381 }
14382 }
14383 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14384 if (!SWIG_IsOK(res2)) {
14385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
14386 }
14387 arg2 = (char *)(buf2);
14388 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14389 if (!SWIG_IsOK(ecode3)) {
14390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
14391 }
14392 arg3 = (PLFLT)(val3);
14393 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14394 if (!SWIG_IsOK(ecode4)) {
14395 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
14396 }
14397 arg4 = (PLFLT)(val4);
14398 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14399 if (!SWIG_IsOK(ecode5)) {
14400 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
14401 }
14402 arg5 = (PLFLT)(val5);
14403 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14404 if (!SWIG_IsOK(ecode6)) {
14405 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14406 }
14407 arg6 = (PLFLT)(val6);
14408 {
14409 if ( swig_obj[6] != Py_None )
14410 {
14411 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14412 if ( tmp7 == NULL )
14413 return NULL;
14414 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14415 arg8 = PyArray_DIMS( tmp7 )[0];
14416 }
14417 else
14418 {
14419 arg7 = NULL;
14420 arg8 = 0;
14421 }
14422 }
14423 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14424 resultobj = SWIG_Py_Void();
14425 {
14427 }
14428 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14429 {
14430 Py_CLEAR( tmp7 );
14431 }
14432 return resultobj;
14433fail:
14434 {
14436 }
14437 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14438 {
14439 Py_CLEAR( tmp7 );
14440 }
14441 return NULL;
14442}
14443
14444
14445SWIGINTERN PyObject *_wrap_plmapstring(PyObject *self, PyObject *args) {
14446 PyObject *resultobj = 0;
14447 mapform_func arg1 = (mapform_func) 0 ;
14448 char *arg2 = (char *) 0 ;
14449 char *arg3 = (char *) 0 ;
14450 PLFLT arg4 ;
14451 PLFLT arg5 ;
14452 PLFLT arg6 ;
14453 PLFLT arg7 ;
14454 PLINT *arg8 = (PLINT *) 0 ;
14455 PLINT arg9 ;
14456 int res2 ;
14457 char *buf2 = 0 ;
14458 int alloc2 = 0 ;
14459 int res3 ;
14460 char *buf3 = 0 ;
14461 int alloc3 = 0 ;
14462 double val4 ;
14463 int ecode4 = 0 ;
14464 double val5 ;
14465 int ecode5 = 0 ;
14466 double val6 ;
14467 int ecode6 = 0 ;
14468 double val7 ;
14469 int ecode7 = 0 ;
14470 PyArrayObject *tmp8 = NULL ;
14471 PyObject *swig_obj[8] ;
14472
14473 (void)self;
14474 if (!SWIG_Python_UnpackTuple(args, "plmapstring", 8, 8, swig_obj)) SWIG_fail;
14475 {
14476 // it must be a callable or none
14477 if ( swig_obj[0] == Py_None )
14478 {
14479 arg1 = NULL;
14480 }
14481 else
14482 {
14483 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14484 {
14485 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14486 return NULL;
14487 }
14488 arg1 = marshal_mapform( swig_obj[0] );
14489 }
14490 }
14491 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14492 if (!SWIG_IsOK(res2)) {
14493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14494 }
14495 arg2 = (char *)(buf2);
14496 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
14497 if (!SWIG_IsOK(res3)) {
14498 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14499 }
14500 arg3 = (char *)(buf3);
14501 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14502 if (!SWIG_IsOK(ecode4)) {
14503 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14504 }
14505 arg4 = (PLFLT)(val4);
14506 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14507 if (!SWIG_IsOK(ecode5)) {
14508 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14509 }
14510 arg5 = (PLFLT)(val5);
14511 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14512 if (!SWIG_IsOK(ecode6)) {
14513 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14514 }
14515 arg6 = (PLFLT)(val6);
14516 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14517 if (!SWIG_IsOK(ecode7)) {
14518 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14519 }
14520 arg7 = (PLFLT)(val7);
14521 {
14522 if ( swig_obj[7] != Py_None )
14523 {
14524 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
14525 if ( tmp8 == NULL )
14526 return NULL;
14527 arg8 = (PLINT *) PyArray_DATA( tmp8 );
14528 arg9 = PyArray_DIMS( tmp8 )[0];
14529 }
14530 else
14531 {
14532 arg8 = NULL;
14533 arg9 = 0;
14534 }
14535 }
14536 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14537 resultobj = SWIG_Py_Void();
14538 {
14540 }
14541 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14542 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14543 {
14544 Py_CLEAR( tmp8 );
14545 }
14546 return resultobj;
14547fail:
14548 {
14550 }
14551 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14552 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14553 {
14554 Py_CLEAR( tmp8 );
14555 }
14556 return NULL;
14557}
14558
14559
14560SWIGINTERN PyObject *_wrap_plmaptex(PyObject *self, PyObject *args) {
14561 PyObject *resultobj = 0;
14562 mapform_func arg1 = (mapform_func) 0 ;
14563 char *arg2 = (char *) 0 ;
14564 PLFLT arg3 ;
14565 PLFLT arg4 ;
14566 PLFLT arg5 ;
14567 char *arg6 = (char *) 0 ;
14568 PLFLT arg7 ;
14569 PLFLT arg8 ;
14570 PLFLT arg9 ;
14571 PLFLT arg10 ;
14572 PLINT arg11 ;
14573 int res2 ;
14574 char *buf2 = 0 ;
14575 int alloc2 = 0 ;
14576 double val3 ;
14577 int ecode3 = 0 ;
14578 double val4 ;
14579 int ecode4 = 0 ;
14580 double val5 ;
14581 int ecode5 = 0 ;
14582 int res6 ;
14583 char *buf6 = 0 ;
14584 int alloc6 = 0 ;
14585 double val7 ;
14586 int ecode7 = 0 ;
14587 double val8 ;
14588 int ecode8 = 0 ;
14589 double val9 ;
14590 int ecode9 = 0 ;
14591 double val10 ;
14592 int ecode10 = 0 ;
14593 int val11 ;
14594 int ecode11 = 0 ;
14595 PyObject *swig_obj[11] ;
14596
14597 (void)self;
14598 if (!SWIG_Python_UnpackTuple(args, "plmaptex", 11, 11, swig_obj)) SWIG_fail;
14599 {
14600 // it must be a callable or none
14601 if ( swig_obj[0] == Py_None )
14602 {
14603 arg1 = NULL;
14604 }
14605 else
14606 {
14607 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14608 {
14609 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14610 return NULL;
14611 }
14612 arg1 = marshal_mapform( swig_obj[0] );
14613 }
14614 }
14615 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14616 if (!SWIG_IsOK(res2)) {
14617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14618 }
14619 arg2 = (char *)(buf2);
14620 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14621 if (!SWIG_IsOK(ecode3)) {
14622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14623 }
14624 arg3 = (PLFLT)(val3);
14625 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14626 if (!SWIG_IsOK(ecode4)) {
14627 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14628 }
14629 arg4 = (PLFLT)(val4);
14630 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14631 if (!SWIG_IsOK(ecode5)) {
14632 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14633 }
14634 arg5 = (PLFLT)(val5);
14635 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
14636 if (!SWIG_IsOK(res6)) {
14637 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14638 }
14639 arg6 = (char *)(buf6);
14640 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14641 if (!SWIG_IsOK(ecode7)) {
14642 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14643 }
14644 arg7 = (PLFLT)(val7);
14645 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14646 if (!SWIG_IsOK(ecode8)) {
14647 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14648 }
14649 arg8 = (PLFLT)(val8);
14650 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14651 if (!SWIG_IsOK(ecode9)) {
14652 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14653 }
14654 arg9 = (PLFLT)(val9);
14655 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14656 if (!SWIG_IsOK(ecode10)) {
14657 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14658 }
14659 arg10 = (PLFLT)(val10);
14660 ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
14661 if (!SWIG_IsOK(ecode11)) {
14662 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14663 }
14664 arg11 = (PLINT)(val11);
14665 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14666 resultobj = SWIG_Py_Void();
14667 {
14669 }
14670 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14671 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14672 return resultobj;
14673fail:
14674 {
14676 }
14677 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14678 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14679 return NULL;
14680}
14681
14682
14683SWIGINTERN PyObject *_wrap_plmapfill(PyObject *self, PyObject *args) {
14684 PyObject *resultobj = 0;
14685 mapform_func arg1 = (mapform_func) 0 ;
14686 char *arg2 = (char *) 0 ;
14687 PLFLT arg3 ;
14688 PLFLT arg4 ;
14689 PLFLT arg5 ;
14690 PLFLT arg6 ;
14691 PLINT *arg7 = (PLINT *) 0 ;
14692 PLINT arg8 ;
14693 int res2 ;
14694 char *buf2 = 0 ;
14695 int alloc2 = 0 ;
14696 double val3 ;
14697 int ecode3 = 0 ;
14698 double val4 ;
14699 int ecode4 = 0 ;
14700 double val5 ;
14701 int ecode5 = 0 ;
14702 double val6 ;
14703 int ecode6 = 0 ;
14704 PyArrayObject *tmp7 = NULL ;
14705 PyObject *swig_obj[7] ;
14706
14707 (void)self;
14708 if (!SWIG_Python_UnpackTuple(args, "plmapfill", 7, 7, swig_obj)) SWIG_fail;
14709 {
14710 // it must be a callable or none
14711 if ( swig_obj[0] == Py_None )
14712 {
14713 arg1 = NULL;
14714 }
14715 else
14716 {
14717 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14718 {
14719 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14720 return NULL;
14721 }
14722 arg1 = marshal_mapform( swig_obj[0] );
14723 }
14724 }
14725 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14726 if (!SWIG_IsOK(res2)) {
14727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14728 }
14729 arg2 = (char *)(buf2);
14730 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14731 if (!SWIG_IsOK(ecode3)) {
14732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14733 }
14734 arg3 = (PLFLT)(val3);
14735 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14736 if (!SWIG_IsOK(ecode4)) {
14737 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14738 }
14739 arg4 = (PLFLT)(val4);
14740 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14741 if (!SWIG_IsOK(ecode5)) {
14742 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14743 }
14744 arg5 = (PLFLT)(val5);
14745 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14746 if (!SWIG_IsOK(ecode6)) {
14747 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14748 }
14749 arg6 = (PLFLT)(val6);
14750 {
14751 if ( swig_obj[6] != Py_None )
14752 {
14753 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14754 if ( tmp7 == NULL )
14755 return NULL;
14756 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14757 arg8 = PyArray_DIMS( tmp7 )[0];
14758 }
14759 else
14760 {
14761 arg7 = NULL;
14762 arg8 = 0;
14763 }
14764 }
14765 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14766 resultobj = SWIG_Py_Void();
14767 {
14769 }
14770 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14771 {
14772 Py_CLEAR( tmp7 );
14773 }
14774 return resultobj;
14775fail:
14776 {
14778 }
14779 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14780 {
14781 Py_CLEAR( tmp7 );
14782 }
14783 return NULL;
14784}
14785
14786
14787SWIGINTERN PyObject *_wrap_plmeridians(PyObject *self, PyObject *args) {
14788 PyObject *resultobj = 0;
14789 mapform_func arg1 = (mapform_func) 0 ;
14790 PLFLT arg2 ;
14791 PLFLT arg3 ;
14792 PLFLT arg4 ;
14793 PLFLT arg5 ;
14794 PLFLT arg6 ;
14795 PLFLT arg7 ;
14796 double val2 ;
14797 int ecode2 = 0 ;
14798 double val3 ;
14799 int ecode3 = 0 ;
14800 double val4 ;
14801 int ecode4 = 0 ;
14802 double val5 ;
14803 int ecode5 = 0 ;
14804 double val6 ;
14805 int ecode6 = 0 ;
14806 double val7 ;
14807 int ecode7 = 0 ;
14808 PyObject *swig_obj[7] ;
14809
14810 (void)self;
14811 if (!SWIG_Python_UnpackTuple(args, "plmeridians", 7, 7, swig_obj)) SWIG_fail;
14812 {
14813 // it must be a callable or none
14814 if ( swig_obj[0] == Py_None )
14815 {
14816 arg1 = NULL;
14817 }
14818 else
14819 {
14820 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14821 {
14822 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14823 return NULL;
14824 }
14825 arg1 = marshal_mapform( swig_obj[0] );
14826 }
14827 }
14828 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14829 if (!SWIG_IsOK(ecode2)) {
14830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14831 }
14832 arg2 = (PLFLT)(val2);
14833 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14834 if (!SWIG_IsOK(ecode3)) {
14835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14836 }
14837 arg3 = (PLFLT)(val3);
14838 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14839 if (!SWIG_IsOK(ecode4)) {
14840 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14841 }
14842 arg4 = (PLFLT)(val4);
14843 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14844 if (!SWIG_IsOK(ecode5)) {
14845 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14846 }
14847 arg5 = (PLFLT)(val5);
14848 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14849 if (!SWIG_IsOK(ecode6)) {
14850 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14851 }
14852 arg6 = (PLFLT)(val6);
14853 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14854 if (!SWIG_IsOK(ecode7)) {
14855 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14856 }
14857 arg7 = (PLFLT)(val7);
14858 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14859 resultobj = SWIG_Py_Void();
14860 {
14862 }
14863 return resultobj;
14864fail:
14865 {
14867 }
14868 return NULL;
14869}
14870
14871
14872SWIGINTERN PyObject *_wrap_plimage(PyObject *self, PyObject *args) {
14873 PyObject *resultobj = 0;
14874 PLFLT **arg1 = (PLFLT **) 0 ;
14875 PLINT arg2 ;
14876 PLINT arg3 ;
14877 PLFLT arg4 ;
14878 PLFLT arg5 ;
14879 PLFLT arg6 ;
14880 PLFLT arg7 ;
14881 PLFLT arg8 ;
14882 PLFLT arg9 ;
14883 PLFLT arg10 ;
14884 PLFLT arg11 ;
14885 PLFLT arg12 ;
14886 PLFLT arg13 ;
14887 PyArrayObject *tmp1 = NULL ;
14888 double val4 ;
14889 int ecode4 = 0 ;
14890 double val5 ;
14891 int ecode5 = 0 ;
14892 double val6 ;
14893 int ecode6 = 0 ;
14894 double val7 ;
14895 int ecode7 = 0 ;
14896 double val8 ;
14897 int ecode8 = 0 ;
14898 double val9 ;
14899 int ecode9 = 0 ;
14900 double val10 ;
14901 int ecode10 = 0 ;
14902 double val11 ;
14903 int ecode11 = 0 ;
14904 double val12 ;
14905 int ecode12 = 0 ;
14906 double val13 ;
14907 int ecode13 = 0 ;
14908 PyObject *swig_obj[11] ;
14909
14910 (void)self;
14911 if (!SWIG_Python_UnpackTuple(args, "plimage", 11, 11, swig_obj)) SWIG_fail;
14912 {
14913 int i, size;
14914 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14915 if ( tmp1 == NULL )
14916 return NULL;
14917 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14918 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14919 size = arg3;
14920 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14921 for ( i = 0; i < arg2; i++ )
14922 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14923 }
14924 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14925 if (!SWIG_IsOK(ecode4)) {
14926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14927 }
14928 arg4 = (PLFLT)(val4);
14929 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14930 if (!SWIG_IsOK(ecode5)) {
14931 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14932 }
14933 arg5 = (PLFLT)(val5);
14934 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14935 if (!SWIG_IsOK(ecode6)) {
14936 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14937 }
14938 arg6 = (PLFLT)(val6);
14939 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14940 if (!SWIG_IsOK(ecode7)) {
14941 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14942 }
14943 arg7 = (PLFLT)(val7);
14944 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14945 if (!SWIG_IsOK(ecode8)) {
14946 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14947 }
14948 arg8 = (PLFLT)(val8);
14949 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14950 if (!SWIG_IsOK(ecode9)) {
14951 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14952 }
14953 arg9 = (PLFLT)(val9);
14954 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14955 if (!SWIG_IsOK(ecode10)) {
14956 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14957 }
14958 arg10 = (PLFLT)(val10);
14959 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14960 if (!SWIG_IsOK(ecode11)) {
14961 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14962 }
14963 arg11 = (PLFLT)(val11);
14964 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
14965 if (!SWIG_IsOK(ecode12)) {
14966 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14967 }
14968 arg12 = (PLFLT)(val12);
14969 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
14970 if (!SWIG_IsOK(ecode13)) {
14971 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14972 }
14973 arg13 = (PLFLT)(val13);
14974 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14975 resultobj = SWIG_Py_Void();
14976 {
14977 Py_CLEAR( tmp1 );
14978 free( arg1 );
14979 }
14980 return resultobj;
14981fail:
14982 {
14983 Py_CLEAR( tmp1 );
14984 free( arg1 );
14985 }
14986 return NULL;
14987}
14988
14989
14990SWIGINTERN PyObject *_wrap_plimagefr(PyObject *self, PyObject *args) {
14991 PyObject *resultobj = 0;
14992 PLFLT **arg1 = (PLFLT **) 0 ;
14993 PLINT arg2 ;
14994 PLINT arg3 ;
14995 PLFLT arg4 ;
14996 PLFLT arg5 ;
14997 PLFLT arg6 ;
14998 PLFLT arg7 ;
14999 PLFLT arg8 ;
15000 PLFLT arg9 ;
15001 PLFLT arg10 ;
15002 PLFLT arg11 ;
15003 pltr_func arg12 = (pltr_func) 0 ;
15004 PLPointer arg13 = (PLPointer) 0 ;
15005 PyArrayObject *tmp1 = NULL ;
15006 double val4 ;
15007 int ecode4 = 0 ;
15008 double val5 ;
15009 int ecode5 = 0 ;
15010 double val6 ;
15011 int ecode6 = 0 ;
15012 double val7 ;
15013 int ecode7 = 0 ;
15014 double val8 ;
15015 int ecode8 = 0 ;
15016 double val9 ;
15017 int ecode9 = 0 ;
15018 double val10 ;
15019 int ecode10 = 0 ;
15020 double val11 ;
15021 int ecode11 = 0 ;
15022 PyObject *swig_obj[11] ;
15023
15024 {
15025 python_pltr = 0;
15026 arg12 = NULL;
15027 }
15028 {
15029 arg13 = NULL;
15030 }
15031 (void)self;
15032 if (!SWIG_Python_UnpackTuple(args, "plimagefr", 9, 11, swig_obj)) SWIG_fail;
15033 {
15034 int i, size;
15035 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15036 if ( tmp1 == NULL )
15037 return NULL;
15038 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15039 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15040 size = arg3;
15041 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15042 for ( i = 0; i < arg2; i++ )
15043 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15044 }
15045 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
15046 if (!SWIG_IsOK(ecode4)) {
15047 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15048 }
15049 arg4 = (PLFLT)(val4);
15050 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
15051 if (!SWIG_IsOK(ecode5)) {
15052 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15053 }
15054 arg5 = (PLFLT)(val5);
15055 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
15056 if (!SWIG_IsOK(ecode6)) {
15057 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15058 }
15059 arg6 = (PLFLT)(val6);
15060 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
15061 if (!SWIG_IsOK(ecode7)) {
15062 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15063 }
15064 arg7 = (PLFLT)(val7);
15065 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
15066 if (!SWIG_IsOK(ecode8)) {
15067 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15068 }
15069 arg8 = (PLFLT)(val8);
15070 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
15071 if (!SWIG_IsOK(ecode9)) {
15072 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15073 }
15074 arg9 = (PLFLT)(val9);
15075 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
15076 if (!SWIG_IsOK(ecode10)) {
15077 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15078 }
15079 arg10 = (PLFLT)(val10);
15080 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
15081 if (!SWIG_IsOK(ecode11)) {
15082 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15083 }
15084 arg11 = (PLFLT)(val11);
15085 if (swig_obj[9]) {
15086 {
15087 // it must be a callable or None
15088 if ( swig_obj[9] == Py_None )
15089 {
15090 arg12 = NULL;
15091 }
15092 else
15093 {
15094 if ( !PyCallable_Check( (PyObject *) swig_obj[9] ) )
15095 {
15096 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
15097 return NULL;
15098 }
15099 arg12 = marshal_pltr( swig_obj[9] );
15100 }
15101 }
15102 }
15103 if (swig_obj[10]) {
15104 {
15105 if ( swig_obj[10] == Py_None )
15106 arg13 = NULL;
15107 else
15108 {
15109 arg13 = marshal_PLPointer( swig_obj[10], 1 );
15110 }
15111 }
15112 }
15113 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15114 resultobj = SWIG_Py_Void();
15115 {
15116 Py_CLEAR( tmp1 );
15117 free( arg1 );
15118 }
15119 {
15120 cleanup_pltr();
15121 }
15122 {
15124 }
15125 return resultobj;
15126fail:
15127 {
15128 Py_CLEAR( tmp1 );
15129 free( arg1 );
15130 }
15131 {
15132 cleanup_pltr();
15133 }
15134 {
15136 }
15137 return NULL;
15138}
15139
15140
15141SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *self, PyObject *args) {
15142 PyObject *resultobj = 0;
15143
15144 (void)self;
15145 if (!SWIG_Python_UnpackTuple(args, "plClearOpts", 0, 0, 0)) SWIG_fail;
15146 plClearOpts();
15147 resultobj = SWIG_Py_Void();
15148 return resultobj;
15149fail:
15150 return NULL;
15151}
15152
15153
15154SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *self, PyObject *args) {
15155 PyObject *resultobj = 0;
15156
15157 (void)self;
15158 if (!SWIG_Python_UnpackTuple(args, "plResetOpts", 0, 0, 0)) SWIG_fail;
15159 plResetOpts();
15160 resultobj = SWIG_Py_Void();
15161 return resultobj;
15162fail:
15163 return NULL;
15164}
15165
15166
15167SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *self, PyObject *args) {
15168 PyObject *resultobj = 0;
15169 char *arg1 = (char *) 0 ;
15170 char *arg2 = (char *) 0 ;
15171 int res1 ;
15172 char *buf1 = 0 ;
15173 int alloc1 = 0 ;
15174 int res2 ;
15175 char *buf2 = 0 ;
15176 int alloc2 = 0 ;
15177 PyObject *swig_obj[2] ;
15178
15179 (void)self;
15180 if (!SWIG_Python_UnpackTuple(args, "plSetUsage", 2, 2, swig_obj)) SWIG_fail;
15181 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
15182 if (!SWIG_IsOK(res1)) {
15183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
15184 }
15185 arg1 = (char *)(buf1);
15186 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
15187 if (!SWIG_IsOK(res2)) {
15188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
15189 }
15190 arg2 = (char *)(buf2);
15191 plSetUsage((char const *)arg1,(char const *)arg2);
15192 resultobj = SWIG_Py_Void();
15193 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15194 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15195 return resultobj;
15196fail:
15197 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15198 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15199 return NULL;
15200}
15201
15202
15203SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *self, PyObject *args) {
15204 PyObject *resultobj = 0;
15205
15206 (void)self;
15207 if (!SWIG_Python_UnpackTuple(args, "plOptUsage", 0, 0, 0)) SWIG_fail;
15208 plOptUsage();
15209 resultobj = SWIG_Py_Void();
15210 return resultobj;
15211fail:
15212 return NULL;
15213}
15214
15215
15216SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *self, PyObject *args) {
15217 PyObject *resultobj = 0;
15218 PLFLT **arg1 = (PLFLT **) 0 ;
15219 PLINT arg2 ;
15220 PLINT arg3 ;
15221 PLFLT *arg4 = (PLFLT *) 0 ;
15222 PLFLT *arg5 = (PLFLT *) 0 ;
15223 PyArrayObject *tmp1 = NULL ;
15224 PLFLT temp4 ;
15225 int res4 = SWIG_TMPOBJ ;
15226 PLFLT temp5 ;
15227 int res5 = SWIG_TMPOBJ ;
15228 PyObject *swig_obj[1] ;
15229
15230 arg4 = &temp4;
15231 arg5 = &temp5;
15232 (void)self;
15233 if (!args) SWIG_fail;
15234 swig_obj[0] = args;
15235 {
15236 int i, size;
15237 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15238 if ( tmp1 == NULL )
15239 return NULL;
15240 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15241 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15242 size = arg3;
15243 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15244 for ( i = 0; i < arg2; i++ )
15245 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15246 }
15247 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
15248 resultobj = SWIG_Py_Void();
15249 if (SWIG_IsTmpObj(res4)) {
15250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
15251 } else {
15252 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15254 }
15255 if (SWIG_IsTmpObj(res5)) {
15256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
15257 } else {
15258 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15259 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
15260 }
15261 {
15262 Py_CLEAR( tmp1 );
15263 free( arg1 );
15264 }
15265 return resultobj;
15266fail:
15267 {
15268 Py_CLEAR( tmp1 );
15269 free( arg1 );
15270 }
15271 return NULL;
15272}
15273
15274
15275SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *self, PyObject *args) {
15276 PyObject *resultobj = 0;
15277 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15278 void *argp1 = 0 ;
15279 int res1 = 0 ;
15280 PyObject *swig_obj[1] ;
15281 PLINT result;
15282
15283 (void)self;
15284 if (!args) SWIG_fail;
15285 swig_obj[0] = args;
15286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15287 if (!SWIG_IsOK(res1)) {
15288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15289 }
15290 arg1 = (PLGraphicsIn *)(argp1);
15291 result = (PLINT)plGetCursor(arg1);
15292 resultobj = SWIG_From_int((int)(result));
15293 return resultobj;
15294fail:
15295 return NULL;
15296}
15297
15298
15299static PyMethodDef SwigMethods[] = {
15300 { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
15301 { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
15302 { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
15303 { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
15304 { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_O, NULL},
15305 { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
15306 { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_O, NULL},
15307 { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
15308 { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_O, NULL},
15309 { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
15310 { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_O, NULL},
15311 { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
15312 { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_O, NULL},
15313 { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
15314 { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_O, NULL},
15315 { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
15316 { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_O, NULL},
15317 { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
15318 { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_O, NULL},
15319 { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
15320 { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_O, NULL},
15321 { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
15322 { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_O, NULL},
15323 { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
15324 { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_O, NULL},
15325 { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
15326 { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_O, NULL},
15327 { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_NOARGS, NULL},
15328 { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_O, NULL},
15329 { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_O, NULL},
15330 { "PLGraphicsIn_swiginit", PLGraphicsIn_swiginit, METH_VARARGS, NULL},
15331 { "plsxwin", _wrap_plsxwin, METH_O, NULL},
15332 { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, "\n"
15333 "Set format of numerical label for contours\n"
15334 "\n"
15335 "DESCRIPTION:\n"
15336 "\n"
15337 " Set format of numerical label for contours.\n"
15338 "\n"
15339 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15340 "\n"
15341 " This function is used example 9.\n"
15342 "\n"
15343 "\n"
15344 "\n"
15345 "SYNOPSIS:\n"
15346 "\n"
15347 "pl_setcontlabelformat(lexp, sigdig)\n"
15348 "\n"
15349 "ARGUMENTS:\n"
15350 "\n"
15351 " lexp (PLINT, input) : If the contour numerical label is greater\n"
15352 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15353 " format is used. Default value of lexp is 4.\n"
15354 "\n"
15355 " sigdig (PLINT, input) : Number of significant digits. Default\n"
15356 " value is 2.\n"
15357 "\n"
15358 ""},
15359 { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, "\n"
15360 "Set parameters of contour labelling other than format of numerical label\n"
15361 "\n"
15362 "DESCRIPTION:\n"
15363 "\n"
15364 " Set parameters of contour labelling other than those handled by\n"
15365 " pl_setcontlabelformat.\n"
15366 "\n"
15367 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15368 "\n"
15369 " This function is used in example 9.\n"
15370 "\n"
15371 "\n"
15372 "\n"
15373 "SYNOPSIS:\n"
15374 "\n"
15375 "pl_setcontlabelparam(offset, size, spacing, active)\n"
15376 "\n"
15377 "ARGUMENTS:\n"
15378 "\n"
15379 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15380 " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
15381 "\n"
15382 " size (PLFLT, input) : Font height for contour labels (normalized).\n"
15383 " Default value is 0.3.\n"
15384 "\n"
15385 " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
15386 " Default value is 0.1.\n"
15387 "\n"
15388 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15389 " contour labels on. Default is off (0).\n"
15390 "\n"
15391 ""},
15392 { "pladv", _wrap_pladv, METH_O, "\n"
15393 "Advance the (sub-)page\n"
15394 "\n"
15395 "DESCRIPTION:\n"
15396 "\n"
15397 " Advances to the next subpage if sub=0, performing a page advance if\n"
15398 " there are no remaining subpages on the current page. If subpages\n"
15399 " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15400 " PLplot switches to the specified subpage. Note that this allows you\n"
15401 " to overwrite a plot on the specified subpage; if this is not what you\n"
15402 " intended, use pleop followed by plbop to first advance the page. This\n"
15403 " routine is called automatically (with page=0) by plenv, but if plenv\n"
15404 " is not used, pladv must be called after initializing PLplot but before\n"
15405 " defining the viewport.\n"
15406 "\n"
15407 " Redacted form: pladv(page)\n"
15408 "\n"
15409 " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
15410 " 29, and 31.\n"
15411 "\n"
15412 "\n"
15413 "\n"
15414 "SYNOPSIS:\n"
15415 "\n"
15416 "pladv(page)\n"
15417 "\n"
15418 "ARGUMENTS:\n"
15419 "\n"
15420 " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15421 " in the top left corner and increasing along the rows) to which to\n"
15422 " advance. Set to zero to advance to the next subpage (or to the\n"
15423 " next page if subpages are not being used).\n"
15424 "\n"
15425 ""},
15426 { "plarc", _wrap_plarc, METH_VARARGS, "\n"
15427 "Draw a circular or elliptical arc\n"
15428 "\n"
15429 "DESCRIPTION:\n"
15430 "\n"
15431 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15432 " semiminor axis b, starting at angle1 and ending at angle2.\n"
15433 "\n"
15434 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15435 " fill)\n"
15436 "\n"
15437 "\n"
15438 " This function is used in examples 3 and 27.\n"
15439 "\n"
15440 "\n"
15441 "\n"
15442 "SYNOPSIS:\n"
15443 "\n"
15444 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15445 "\n"
15446 "ARGUMENTS:\n"
15447 "\n"
15448 " x (PLFLT, input) : X coordinate of arc center.\n"
15449 "\n"
15450 " y (PLFLT, input) : Y coordinate of arc center.\n"
15451 "\n"
15452 " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15453 "\n"
15454 " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15455 "\n"
15456 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15457 " semimajor axis.\n"
15458 "\n"
15459 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15460 " semimajor axis.\n"
15461 "\n"
15462 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15463 " X-axis.\n"
15464 "\n"
15465 " fill (PLBOOL, input) : Draw a filled arc.\n"
15466 "\n"
15467 ""},
15468 { "plaxes", _wrap_plaxes, METH_VARARGS, "\n"
15469 "Draw a box with axes, etc. with arbitrary origin\n"
15470 "\n"
15471 "DESCRIPTION:\n"
15472 "\n"
15473 " Draws a box around the currently defined viewport with arbitrary\n"
15474 " world-coordinate origin specified by x0 and y0 and labels it with\n"
15475 " world coordinate values appropriate to the window. Thus plaxes should\n"
15476 " only be called after defining both viewport and window. The ascii\n"
15477 " character strings xopt and yopt specify how the box should be drawn as\n"
15478 " described below. If ticks and/or subticks are to be drawn for a\n"
15479 " particular axis, the tick intervals and number of subintervals may be\n"
15480 " specified explicitly, or they may be defaulted by setting the\n"
15481 " appropriate arguments to zero.\n"
15482 "\n"
15483 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15484 " ytick, nysub)\n"
15485 "\n"
15486 "\n"
15487 " This function is not used in any examples.\n"
15488 "\n"
15489 "\n"
15490 "\n"
15491 "SYNOPSIS:\n"
15492 "\n"
15493 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15494 "\n"
15495 "ARGUMENTS:\n"
15496 "\n"
15497 " x0 (PLFLT, input) : World X coordinate of origin.\n"
15498 "\n"
15499 " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15500 "\n"
15501 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15502 " options for the x axis. The string can include any combination of\n"
15503 " the following letters (upper or lower case) in any order: a: Draws\n"
15504 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15505 " (x=0).\n"
15506 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15507 " c: Draws top (X) or right (Y) edge of frame.\n"
15508 " d: Plot labels as date / time. Values are assumed to be\n"
15509 " seconds since the epoch (as used by gmtime).\n"
15510 " f: Always use fixed point numeric labels.\n"
15511 " g: Draws a grid at the major tick interval.\n"
15512 " h: Draws a grid at the minor tick interval.\n"
15513 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15514 " inwards.\n"
15515 " l: Labels axis logarithmically. This only affects the labels,\n"
15516 " not the data, and so it is necessary to compute the logarithms\n"
15517 " of data points before passing them to any of the drawing\n"
15518 " routines.\n"
15519 " m: Writes numeric labels at major tick intervals in the\n"
15520 " unconventional location (above box for X, right of box for Y).\n"
15521 " n: Writes numeric labels at major tick intervals in the\n"
15522 " conventional location (below box for X, left of box for Y).\n"
15523 " o: Use custom labelling function to generate axis label text.\n"
15524 " The custom labelling function can be defined with the\n"
15525 " plslabelfunc command.\n"
15526 " s: Enables subticks between major ticks, only valid if t is\n"
15527 " also specified.\n"
15528 " t: Draws major ticks.\n"
15529 " u: Exactly like \"b\" except don't draw edge line.\n"
15530 " w: Exactly like \"c\" except don't draw edge line.\n"
15531 " x: Exactly like \"t\" (including the side effect of the\n"
15532 " numerical labels for the major ticks) except exclude drawing\n"
15533 " the major and minor tick marks.\n"
15534 "\n"
15535 "\n"
15536 " xtick (PLFLT, input) : World coordinate interval between major\n"
15537 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15538 " generates a suitable tick interval.\n"
15539 "\n"
15540 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15541 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15542 " generates a suitable minor tick interval.\n"
15543 "\n"
15544 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15545 " options for the y axis. The string can include any combination of\n"
15546 " the letters defined above for xopt, and in addition may contain:\n"
15547 " v: Write numeric labels for the y axis parallel to the base of the\n"
15548 " graph, rather than parallel to the axis.\n"
15549 "\n"
15550 "\n"
15551 " ytick (PLFLT, input) : World coordinate interval between major\n"
15552 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15553 " generates a suitable tick interval.\n"
15554 "\n"
15555 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15556 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15557 " generates a suitable minor tick interval.\n"
15558 "\n"
15559 ""},
15560 { "plbin", _wrap_plbin, METH_VARARGS, "\n"
15561 "Plot a histogram from binned data\n"
15562 "\n"
15563 "DESCRIPTION:\n"
15564 "\n"
15565 " Plots a histogram consisting of nbin bins. The value associated with\n"
15566 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15567 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15568 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15569 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15570 " placed midway between the values in the x vector. Also see plhist for\n"
15571 " drawing histograms from unbinned data.\n"
15572 "\n"
15573 " Redacted form: General: plbin(x, y, opt)\n"
15574 " Python: plbin(nbin, x, y, opt)\n"
15575 "\n"
15576 "\n"
15577 " This function is not used in any examples.\n"
15578 "\n"
15579 "\n"
15580 "\n"
15581 "SYNOPSIS:\n"
15582 "\n"
15583 "plbin(nbin, x, y, opt)\n"
15584 "\n"
15585 "ARGUMENTS:\n"
15586 "\n"
15587 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15588 " and y vectors.)\n"
15589 "\n"
15590 " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15591 " with bins. These must form a strictly increasing sequence.\n"
15592 "\n"
15593 " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15594 " proportional to the number of points in each bin. This is a PLFLT\n"
15595 " (instead of PLINT) vector so as to allow histograms of\n"
15596 " probabilities, etc.\n"
15597 "\n"
15598 " opt (PLINT, input) : Is a combination of several flags:\n"
15599 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15600 " outer bins are expanded to fill up the entire x-axis and bins of\n"
15601 " zero height are simply drawn.\n"
15602 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15603 " between the x values. If the values in x are equally spaced,\n"
15604 " the values are the center values of the bins.\n"
15605 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15606 " size as the ones inside.\n"
15607 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15608 " (there is a gap for such bins).\n"
15609 "\n"
15610 ""},
15611 { "plbtime", _wrap_plbtime, METH_O, "\n"
15612 "Calculate broken-down time from continuous time for the current stream\n"
15613 "\n"
15614 "DESCRIPTION:\n"
15615 "\n"
15616 " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15617 " continuous time, ctime for the current stream. This function is the\n"
15618 " inverse of plctime.\n"
15619 "\n"
15620 " The PLplot definition of broken-down time is a calendar time that\n"
15621 " completely ignores all time zone offsets, i.e., it is the user's\n"
15622 " responsibility to apply those offsets (if so desired) before using the\n"
15623 " PLplot time API. By default broken-down time is defined using the\n"
15624 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15625 " continuous time is defined as the number of seconds since the Unix\n"
15626 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15627 " broken-down and continuous time are possible, see plconfigtime.\n"
15628 "\n"
15629 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15630 " ctime)\n"
15631 "\n"
15632 "\n"
15633 " This function is used in example 29.\n"
15634 "\n"
15635 "\n"
15636 "\n"
15637 "SYNOPSIS:\n"
15638 "\n"
15639 "plbtime(year, month, day, hour, min, sec, ctime)\n"
15640 "\n"
15641 "ARGUMENTS:\n"
15642 "\n"
15643 " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15644 " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15645 " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15646 " BCE, etc.)\n"
15647 "\n"
15648 " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15649 " the year in the range from 0 (January) to 11 (December).\n"
15650 "\n"
15651 " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15652 " month in the range from 1 to 31.\n"
15653 "\n"
15654 " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15655 " day in the range from 0 to 23.\n"
15656 "\n"
15657 " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15658 " hour in the range from 0 to 59\n"
15659 "\n"
15660 " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15661 " minute in range from 0. to 60.\n"
15662 "\n"
15663 " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
15664 " time is calculated.\n"
15665 "\n"
15666 ""},
15667 { "plbop", _wrap_plbop, METH_NOARGS, "\n"
15668 "Begin a new page\n"
15669 "\n"
15670 "DESCRIPTION:\n"
15671 "\n"
15672 " Begins a new page. For a file driver, the output file is opened if\n"
15673 " necessary. Advancing the page via pleop and plbop is useful when a\n"
15674 " page break is desired at a particular point when plotting to subpages.\n"
15675 " Another use for pleop and plbop is when plotting pages to different\n"
15676 " files, since you can manually set the file name by calling plsfnam\n"
15677 " after the call to pleop. (In fact some drivers may only support a\n"
15678 " single page per file, making this a necessity.) One way to handle\n"
15679 " this case automatically is to page advance via pladv, but enable\n"
15680 " familying (see plsfam) with a small limit on the file size so that a\n"
15681 " new family member file will be created on each page break.\n"
15682 "\n"
15683 " Redacted form: plbop()\n"
15684 "\n"
15685 " This function is used in examples 2 and 20.\n"
15686 "\n"
15687 "\n"
15688 "\n"
15689 "SYNOPSIS:\n"
15690 "\n"
15691 "plbop()\n"
15692 "\n"
15693 ""},
15694 { "plbox", _wrap_plbox, METH_VARARGS, "\n"
15695 "Draw a box with axes, etc\n"
15696 "\n"
15697 "DESCRIPTION:\n"
15698 "\n"
15699 " Draws a box around the currently defined viewport, and labels it with\n"
15700 " world coordinate values appropriate to the window. Thus plbox should\n"
15701 " only be called after defining both viewport and window. The ascii\n"
15702 " character strings xopt and yopt specify how the box should be drawn as\n"
15703 " described below. If ticks and/or subticks are to be drawn for a\n"
15704 " particular axis, the tick intervals and number of subintervals may be\n"
15705 " specified explicitly, or they may be defaulted by setting the\n"
15706 " appropriate arguments to zero.\n"
15707 "\n"
15708 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15709 "\n"
15710 "\n"
15711 " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15712 " and 29.\n"
15713 "\n"
15714 "\n"
15715 "\n"
15716 "SYNOPSIS:\n"
15717 "\n"
15718 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15719 "\n"
15720 "ARGUMENTS:\n"
15721 "\n"
15722 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15723 " options for the x axis. The string can include any combination of\n"
15724 " the following letters (upper or lower case) in any order: a: Draws\n"
15725 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15726 " (x=0).\n"
15727 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15728 " c: Draws top (X) or right (Y) edge of frame.\n"
15729 " d: Plot labels as date / time. Values are assumed to be\n"
15730 " seconds since the epoch (as used by gmtime).\n"
15731 " f: Always use fixed point numeric labels.\n"
15732 " g: Draws a grid at the major tick interval.\n"
15733 " h: Draws a grid at the minor tick interval.\n"
15734 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15735 " inwards.\n"
15736 " l: Labels axis logarithmically. This only affects the labels,\n"
15737 " not the data, and so it is necessary to compute the logarithms\n"
15738 " of data points before passing them to any of the drawing\n"
15739 " routines.\n"
15740 " m: Writes numeric labels at major tick intervals in the\n"
15741 " unconventional location (above box for X, right of box for Y).\n"
15742 " n: Writes numeric labels at major tick intervals in the\n"
15743 " conventional location (below box for X, left of box for Y).\n"
15744 " o: Use custom labelling function to generate axis label text.\n"
15745 " The custom labelling function can be defined with the\n"
15746 " plslabelfunc command.\n"
15747 " s: Enables subticks between major ticks, only valid if t is\n"
15748 " also specified.\n"
15749 " t: Draws major ticks.\n"
15750 " u: Exactly like \"b\" except don't draw edge line.\n"
15751 " w: Exactly like \"c\" except don't draw edge line.\n"
15752 " x: Exactly like \"t\" (including the side effect of the\n"
15753 " numerical labels for the major ticks) except exclude drawing\n"
15754 " the major and minor tick marks.\n"
15755 "\n"
15756 "\n"
15757 " xtick (PLFLT, input) : World coordinate interval between major\n"
15758 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15759 " generates a suitable tick interval.\n"
15760 "\n"
15761 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15762 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15763 " generates a suitable minor tick interval.\n"
15764 "\n"
15765 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15766 " options for the y axis. The string can include any combination of\n"
15767 " the letters defined above for xopt, and in addition may contain:\n"
15768 " v: Write numeric labels for the y axis parallel to the base of the\n"
15769 " graph, rather than parallel to the axis.\n"
15770 "\n"
15771 "\n"
15772 " ytick (PLFLT, input) : World coordinate interval between major\n"
15773 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15774 " generates a suitable tick interval.\n"
15775 "\n"
15776 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15777 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15778 " generates a suitable minor tick interval.\n"
15779 "\n"
15780 ""},
15781 { "plbox3", _wrap_plbox3, METH_VARARGS, "\n"
15782 "Draw a box with axes, etc, in 3-d\n"
15783 "\n"
15784 "DESCRIPTION:\n"
15785 "\n"
15786 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15787 " plot. For a more complete description of three-dimensional plotting\n"
15788 " see the PLplot documentation.\n"
15789 "\n"
15790 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15791 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15792 "\n"
15793 "\n"
15794 " This function is used in examples 8, 11, 18, and 21.\n"
15795 "\n"
15796 "\n"
15797 "\n"
15798 "SYNOPSIS:\n"
15799 "\n"
15800 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15801 "\n"
15802 "ARGUMENTS:\n"
15803 "\n"
15804 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15805 " options for the x axis. The string can include any combination of\n"
15806 " the following letters (upper or lower case) in any order: b: Draws\n"
15807 " axis at base, at height z=\n"
15808 " zmin where zmin is defined by call to plw3d. This character must be\n"
15809 " specified in order to use any of the other options.\n"
15810 " d: Plot labels as date / time. Values are assumed to be\n"
15811 " seconds since the epoch (as used by gmtime).\n"
15812 " f: Always use fixed point numeric labels.\n"
15813 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15814 " than upwards.\n"
15815 " l: Labels axis logarithmically. This only affects the labels,\n"
15816 " not the data, and so it is necessary to compute the logarithms\n"
15817 " of data points before passing them to any of the drawing\n"
15818 " routines.\n"
15819 " n: Writes numeric labels at major tick intervals.\n"
15820 " o: Use custom labelling function to generate axis label text.\n"
15821 " The custom labelling function can be defined with the\n"
15822 " plslabelfunc command.\n"
15823 " s: Enables subticks between major ticks, only valid if t is\n"
15824 " also specified.\n"
15825 " t: Draws major ticks.\n"
15826 " u: If this is specified, the text label for the axis is\n"
15827 " written under the axis.\n"
15828 "\n"
15829 "\n"
15830 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15831 " the text label for the x axis. It is only drawn if u is in the\n"
15832 " xopt string.\n"
15833 "\n"
15834 " xtick (PLFLT, input) : World coordinate interval between major\n"
15835 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15836 " generates a suitable tick interval.\n"
15837 "\n"
15838 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15839 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15840 " generates a suitable minor tick interval.\n"
15841 "\n"
15842 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15843 " options for the y axis. The string is interpreted in the same way\n"
15844 " as xopt.\n"
15845 "\n"
15846 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15847 " the text label for the y axis. It is only drawn if u is in the\n"
15848 " yopt string.\n"
15849 "\n"
15850 " ytick (PLFLT, input) : World coordinate interval between major\n"
15851 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15852 " generates a suitable tick interval.\n"
15853 "\n"
15854 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15855 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15856 " generates a suitable minor tick interval.\n"
15857 "\n"
15858 " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15859 " options for the z axis. The string can include any combination of\n"
15860 " the following letters (upper or lower case) in any order: b: Draws\n"
15861 " z axis to the left of the surface plot.\n"
15862 " c: Draws z axis to the right of the surface plot.\n"
15863 " d: Draws grid lines parallel to the x-y plane behind the\n"
15864 " figure. These lines are not drawn until after plot3d or\n"
15865 " plmesh are called because of the need for hidden line removal.\n"
15866 " e: Plot labels as date / time. Values are assumed to be\n"
15867 " seconds since the epoch (as used by gmtime). Note this\n"
15868 " suboption is interpreted the same as the d suboption for xopt\n"
15869 " and yopt, but it has to be identified as e for zopt since d\n"
15870 " has already been used for the different purpose above.\n"
15871 " f: Always use fixed point numeric labels.\n"
15872 " i: Inverts tick marks, so they are drawn away from the center.\n"
15873 " l: Labels axis logarithmically. This only affects the labels,\n"
15874 " not the data, and so it is necessary to compute the logarithms\n"
15875 " of data points before passing them to any of the drawing\n"
15876 " routines.\n"
15877 " m: Writes numeric labels at major tick intervals on the\n"
15878 " right-hand z axis.\n"
15879 " n: Writes numeric labels at major tick intervals on the\n"
15880 " left-hand z axis.\n"
15881 " o: Use custom labelling function to generate axis label text.\n"
15882 " The custom labelling function can be defined with the\n"
15883 " plslabelfunc command.\n"
15884 " s: Enables subticks between major ticks, only valid if t is\n"
15885 " also specified.\n"
15886 " t: Draws major ticks.\n"
15887 " u: If this is specified, the text label is written beside the\n"
15888 " left-hand axis.\n"
15889 " v: If this is specified, the text label is written beside the\n"
15890 " right-hand axis.\n"
15891 "\n"
15892 "\n"
15893 " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15894 " the text label for the z axis. It is only drawn if u or v are in\n"
15895 " the zopt string.\n"
15896 "\n"
15897 " ztick (PLFLT, input) : World coordinate interval between major\n"
15898 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15899 " generates a suitable tick interval.\n"
15900 "\n"
15901 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15902 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15903 " generates a suitable minor tick interval.\n"
15904 "\n"
15905 ""},
15906 { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, "\n"
15907 "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15908 "\n"
15909 "DESCRIPTION:\n"
15910 "\n"
15911 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15912 " from relative device coordinates, rx and ry.\n"
15913 "\n"
15914 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15915 "\n"
15916 "\n"
15917 " This function is used in example 31.\n"
15918 "\n"
15919 "\n"
15920 "\n"
15921 "SYNOPSIS:\n"
15922 "\n"
15923 "plcalc_world(rx, ry, wx, wy, window)\n"
15924 "\n"
15925 "ARGUMENTS:\n"
15926 "\n"
15927 " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15928 " the x coordinate.\n"
15929 "\n"
15930 " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15931 " the y coordinate.\n"
15932 "\n"
15933 " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15934 " coordinate corresponding to the relative device coordinates rx and\n"
15935 " ry.\n"
15936 "\n"
15937 " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15938 " coordinate corresponding to the relative device coordinates rx and\n"
15939 " ry.\n"
15940 "\n"
15941 " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15942 " defined window index that corresponds to the input relative device\n"
15943 " coordinates (and the returned world coordinates). To give some\n"
15944 " background on the window index, for each page the initial window\n"
15945 " index is set to zero, and each time plwind is called within the\n"
15946 " page, world and device coordinates are stored for the window and\n"
15947 " the window index is incremented. Thus, for a simple page layout\n"
15948 " with non-overlapping viewports and one window per viewport, window\n"
15949 " corresponds to the viewport index (in the order which the\n"
15950 " viewport/windows were created) of the only viewport/window\n"
15951 " corresponding to rx and ry. However, for more complicated layouts\n"
15952 " with potentially overlapping viewports and possibly more than one\n"
15953 " window (set of world coordinates) per viewport, window and the\n"
15954 " corresponding output world coordinates corresponds to the last\n"
15955 " window created that fulfills the criterion that the relative\n"
15956 " device coordinates are inside it. Finally, in all cases where the\n"
15957 " input relative device coordinates are not inside any\n"
15958 " viewport/window, then the returned value of the last defined\n"
15959 " window index is set to -1.\n"
15960 "\n"
15961 ""},
15962 { "plclear", _wrap_plclear, METH_NOARGS, "\n"
15963 "Clear current (sub)page\n"
15964 "\n"
15965 "DESCRIPTION:\n"
15966 "\n"
15967 " Clears the current page, effectively erasing everything that have been\n"
15968 " drawn. This command only works with interactive drivers; if the\n"
15969 " driver does not support this, the page is filled with the background\n"
15970 " color in use. If the current page is divided into subpages, only the\n"
15971 " current subpage is erased. The nth subpage can be selected with\n"
15972 " pladv(n).\n"
15973 "\n"
15974 " Redacted form: General: plclear()\n"
15975 "\n"
15976 "\n"
15977 " This function is not used in any examples.\n"
15978 "\n"
15979 "\n"
15980 "\n"
15981 "SYNOPSIS:\n"
15982 "\n"
15983 "plclear()\n"
15984 "\n"
15985 ""},
15986 { "plcol0", _wrap_plcol0, METH_O, "\n"
15987 "Set color, cmap0\n"
15988 "\n"
15989 "DESCRIPTION:\n"
15990 "\n"
15991 " Sets the color index for cmap0 (see the PLplot documentation).\n"
15992 "\n"
15993 " Redacted form: plcol0(icol0)\n"
15994 "\n"
15995 " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
15996 "\n"
15997 "\n"
15998 "\n"
15999 "SYNOPSIS:\n"
16000 "\n"
16001 "plcol0(icol0)\n"
16002 "\n"
16003 "ARGUMENTS:\n"
16004 "\n"
16005 " icol0 (PLINT, input) : Integer representing the color. The\n"
16006 " defaults at present are (these may change):\n"
16007 " 0 black (default background)\n"
16008 " 1 red (default foreground)\n"
16009 " 2 yellow\n"
16010 " 3 green\n"
16011 " 4 aquamarine\n"
16012 " 5 pink\n"
16013 " 6 wheat\n"
16014 " 7 grey\n"
16015 " 8 brown\n"
16016 " 9 blue\n"
16017 " 10 BlueViolet\n"
16018 " 11 cyan\n"
16019 " 12 turquoise\n"
16020 " 13 magenta\n"
16021 " 14 salmon\n"
16022 " 15 white\n"
16023 "\n"
16024 " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
16025 " change an individual color in the cmap0 color palette.\n"
16026 "\n"
16027 ""},
16028 { "plcol1", _wrap_plcol1, METH_O, "\n"
16029 "Set color, cmap1\n"
16030 "\n"
16031 "DESCRIPTION:\n"
16032 "\n"
16033 " Sets the color for cmap1 (see the PLplot documentation).\n"
16034 "\n"
16035 " Redacted form: plcol1(col1)\n"
16036 "\n"
16037 " This function is used in examples 12 and 21.\n"
16038 "\n"
16039 "\n"
16040 "\n"
16041 "SYNOPSIS:\n"
16042 "\n"
16043 "plcol1(col1)\n"
16044 "\n"
16045 "ARGUMENTS:\n"
16046 "\n"
16047 " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
16048 " is mapped to color using the continuous cmap1 palette which by\n"
16049 " default ranges from blue to the background color to red. The\n"
16050 " cmap1 palette can also be straightforwardly changed by the user\n"
16051 " with plscmap1 or plscmap1l.\n"
16052 "\n"
16053 ""},
16054 { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, "\n"
16055 "Configure the transformation between continuous and broken-down time for the current stream\n"
16056 "\n"
16057 "DESCRIPTION:\n"
16058 "\n"
16059 " Configure the transformation between continuous and broken-down time\n"
16060 " for the current stream. This transformation is used by both plbtime\n"
16061 " and plctime.\n"
16062 "\n"
16063 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
16064 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16065 "\n"
16066 "\n"
16067 " This function is used in example 29.\n"
16068 "\n"
16069 "\n"
16070 "\n"
16071 "SYNOPSIS:\n"
16072 "\n"
16073 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16074 "\n"
16075 "ARGUMENTS:\n"
16076 "\n"
16077 " scale (PLFLT, input) : The number of days per continuous time unit.\n"
16078 " As a special case, if\n"
16079 " scale is 0., then all other arguments are ignored, and the result (the\n"
16080 " default used by PLplot) is the equivalent of a call to\n"
16081 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
16082 " That is, for this special case broken-down time is calculated with\n"
16083 " the proleptic Gregorian calendar with no leap seconds inserted,\n"
16084 " and the continuous time is defined as the number of seconds since\n"
16085 " the Unix epoch of 1970-01-01T00:00:00Z.\n"
16086 "\n"
16087 " offset1 (PLFLT, input) : If\n"
16088 " ifbtime_offset is true, the parameters\n"
16089 " offset1 and\n"
16090 " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
16091 " (with units in days) specify the epoch of the continuous time\n"
16092 " relative to the MJD epoch corresponding to the Gregorian calendar\n"
16093 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
16094 " are used to specify the origin to allow users (by specifying\n"
16095 " offset1 as an integer that can be exactly represented by a\n"
16096 " floating-point variable and specifying\n"
16097 " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
16098 " the numerical errors of the continuous time representation.\n"
16099 "\n"
16100 " offset2 (PLFLT, input) : See documentation of\n"
16101 " offset1.\n"
16102 "\n"
16103 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
16104 " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
16105 " calendar is used for broken-down time rather than the proleptic\n"
16106 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
16107 " have been historically used to define UTC are inserted into the\n"
16108 " broken-down time. Other possibilities for additional control bits\n"
16109 " for ccontrol exist such as making the historical time corrections\n"
16110 " in the broken-down time corresponding to ET (ephemeris time) or\n"
16111 " making the (slightly non-constant) corrections from international\n"
16112 " atomic time (TAI) to what astronomers define as terrestrial time\n"
16113 " (TT). But those additional possibilities have not been\n"
16114 " implemented yet in the qsastime library (one of the PLplot utility\n"
16115 " libraries).\n"
16116 "\n"
16117 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
16118 " epoch of the continuous time scale is specified by the user. If\n"
16119 " ifbtime_offset is false, then\n"
16120 " offset1 and\n"
16121 " offset2 are used to specify the epoch, and the following broken-down\n"
16122 " time parameters are completely ignored. If\n"
16123 " ifbtime_offset is true, then\n"
16124 " offset1 and\n"
16125 " offset2 are completely ignored, and the following broken-down time\n"
16126 " parameters are used to specify the epoch.\n"
16127 "\n"
16128 " year (PLINT, input) : Year of epoch.\n"
16129 "\n"
16130 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
16131 " 11 (December).\n"
16132 "\n"
16133 " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
16134 "\n"
16135 " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
16136 "\n"
16137 " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
16138 "\n"
16139 " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
16140 "\n"
16141 ""},
16142 { "plcont", _wrap_plcont, METH_VARARGS, "\n"
16143 "Contour plot\n"
16144 "\n"
16145 "DESCRIPTION:\n"
16146 "\n"
16147 " Draws a contour plot of the data in f[\n"
16148 " nx][\n"
16149 " ny], using the nlevel contour levels specified by clevel. Only the\n"
16150 " region of the matrix from kx to lx and from ky to ly is plotted out\n"
16151 " where all these index ranges are interpreted as one-based for\n"
16152 " historical reasons. A transformation routine pointed to by pltr with\n"
16153 " a generic pointer pltr_data for additional data required by the\n"
16154 " transformation routine is used to map indices within the matrix to the\n"
16155 " world coordinates.\n"
16156 "\n"
16157 " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16158 " where (see above discussion) the pltr, pltr_data callback arguments\n"
16159 " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
16160 " vectors; or xg and yg matrices.\n"
16161 "\n"
16162 " This function is used in examples 9, 14, 16, and 22.\n"
16163 "\n"
16164 "\n"
16165 "\n"
16166 "SYNOPSIS:\n"
16167 "\n"
16168 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16169 "\n"
16170 "ARGUMENTS:\n"
16171 "\n"
16172 " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
16173 "\n"
16174 " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
16175 "\n"
16176 " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
16177 " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
16178 " zero-based for historical backwards-compatibility reasons.\n"
16179 "\n"
16180 " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
16181 " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
16182 " zero-based for historical backwards-compatibility reasons.\n"
16183 "\n"
16184 " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
16185 " which to draw contours.\n"
16186 "\n"
16187 " nlevel (PLINT, input) : Number of contour levels to draw.\n"
16188 "\n"
16189 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
16190 " defines the transformation between the zero-based indices of the\n"
16191 " matrix f and the world coordinates.For the C case, transformation\n"
16192 " functions are provided in the PLplot library: pltr0 for the\n"
16193 " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
16194 " respectively defined by vectors and matrices. In addition, C\n"
16195 " callback routines for the transformation can be supplied by the\n"
16196 " user such as the mypltr function in examples/c/x09c.c which\n"
16197 " provides a general linear transformation between index coordinates\n"
16198 " and world coordinates.For languages other than C you should\n"
16199 " consult the PLplot documentation for the details concerning how\n"
16200 " PLTRANSFORM_callback arguments are interfaced. However, in\n"
16201 " general, a particular pattern of callback-associated arguments\n"
16202 " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
16203 " yg matrices are respectively interfaced to a linear-transformation\n"
16204 " routine similar to the above mypltr function; pltr1; and pltr2.\n"
16205 " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
16206 " the PLplot documentation) support native language callbacks for\n"
16207 " handling index to world-coordinate transformations. Examples of\n"
16208 " these various approaches are given in examples/<language>x09*,\n"
16209 " examples/<language>x16*, examples/<language>x20*,\n"
16210 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
16211 " supported languages.\n"
16212 "\n"
16213 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
16214 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
16215 " that is externally supplied.\n"
16216 "\n"
16217 ""},
16218 { "plctime", _wrap_plctime, METH_VARARGS, "\n"
16219 "Calculate continuous time from broken-down time for the current stream\n"
16220 "\n"
16221 "DESCRIPTION:\n"
16222 "\n"
16223 " Calculate continuous time, ctime, from broken-down time for the\n"
16224 " current stream. The broken-down\n"
16225 " time is specified by the following parameters: year, month, day, hour,\n"
16226 " min, and sec. This function is the inverse of plbtime.\n"
16227 "\n"
16228 " The PLplot definition of broken-down time is a calendar time that\n"
16229 " completely ignores all time zone offsets, i.e., it is the user's\n"
16230 " responsibility to apply those offsets (if so desired) before using the\n"
16231 " PLplot time API. By default broken-down time is defined using the\n"
16232 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16233 " continuous time is defined as the number of seconds since the Unix\n"
16234 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16235 " broken-down and continuous time are possible, see plconfigtime which\n"
16236 " specifies that transformation for the current stream.\n"
16237 "\n"
16238 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16239 " ctime)\n"
16240 "\n"
16241 "\n"
16242 " This function is used in example 29.\n"
16243 "\n"
16244 "\n"
16245 "\n"
16246 "SYNOPSIS:\n"
16247 "\n"
16248 "plctime(year, month, day, hour, min, sec, ctime)\n"
16249 "\n"
16250 "ARGUMENTS:\n"
16251 "\n"
16252 " year (PLINT, input) : Input year.\n"
16253 "\n"
16254 " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16255 " (December).\n"
16256 "\n"
16257 " day (PLINT, input) : Input day in range from 1 to 31.\n"
16258 "\n"
16259 " hour (PLINT, input) : Input hour in range from 0 to 23\n"
16260 "\n"
16261 " min (PLINT, input) : Input minute in range from 0 to 59.\n"
16262 "\n"
16263 " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
16264 "\n"
16265 " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
16266 " time calculated from the broken-down time specified by the\n"
16267 " previous parameters.\n"
16268 "\n"
16269 ""},
16270 { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, "\n"
16271 "Copy state parameters from the reference stream to the current stream\n"
16272 "\n"
16273 "DESCRIPTION:\n"
16274 "\n"
16275 " Copies state parameters from the reference stream to the current\n"
16276 " stream. Tell driver interface to map device coordinates unless flags\n"
16277 " == 1.\n"
16278 "\n"
16279 " This function is used for making save files of selected plots (e.g.\n"
16280 " from the TK driver). After initializing, you can get a copy of the\n"
16281 " current plot to the specified device by switching to this stream and\n"
16282 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16283 " appropriate. The plot buffer must have previously been enabled (done\n"
16284 " automatically by some display drivers, such as X).\n"
16285 "\n"
16286 " Redacted form: plcpstrm(iplsr, flags)\n"
16287 "\n"
16288 " This function is used in example 1,20.\n"
16289 "\n"
16290 "\n"
16291 "\n"
16292 "SYNOPSIS:\n"
16293 "\n"
16294 "plcpstrm(iplsr, flags)\n"
16295 "\n"
16296 "ARGUMENTS:\n"
16297 "\n"
16298 " iplsr (PLINT, input) : Number of reference stream.\n"
16299 "\n"
16300 " flags (PLBOOL, input) : If flags is set to true the device\n"
16301 " coordinates are not copied from the reference to current stream.\n"
16302 "\n"
16303 ""},
16304 { "plend", _wrap_plend, METH_NOARGS, "\n"
16305 "End plotting session\n"
16306 "\n"
16307 "DESCRIPTION:\n"
16308 "\n"
16309 " Ends a plotting session, tidies up all the output files, switches\n"
16310 " interactive devices back into text mode and frees up any memory that\n"
16311 " was allocated. Must be called before end of program.\n"
16312 "\n"
16313 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16314 " wait state after a call to plend or other functions which trigger the\n"
16315 " end of a plot page. To avoid this, use the plspause function.\n"
16316 "\n"
16317 " Redacted form: plend()\n"
16318 "\n"
16319 " This function is used in all of the examples.\n"
16320 "\n"
16321 "\n"
16322 "\n"
16323 "SYNOPSIS:\n"
16324 "\n"
16325 "plend()\n"
16326 "\n"
16327 ""},
16328 { "plend1", _wrap_plend1, METH_NOARGS, "\n"
16329 "End plotting session for current stream\n"
16330 "\n"
16331 "DESCRIPTION:\n"
16332 "\n"
16333 " Ends a plotting session for the current output stream only. See\n"
16334 " plsstrm for more info.\n"
16335 "\n"
16336 " Redacted form: plend1()\n"
16337 "\n"
16338 " This function is used in examples 1 and 20.\n"
16339 "\n"
16340 "\n"
16341 "\n"
16342 "SYNOPSIS:\n"
16343 "\n"
16344 "plend1()\n"
16345 "\n"
16346 ""},
16347 { "plenv", _wrap_plenv, METH_VARARGS, "\n"
16348 "Set up standard window and draw box\n"
16349 "\n"
16350 "DESCRIPTION:\n"
16351 "\n"
16352 " Sets up plotter environment for simple graphs by calling pladv and\n"
16353 " setting up viewport and window to sensible default values. plenv\n"
16354 " leaves a standard margin (left-hand margin of eight character heights,\n"
16355 " and a margin around the other three sides of five character heights)\n"
16356 " around most graphs for axis labels and a title. When these defaults\n"
16357 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16358 " plvasp for setting up the viewport, plwind for defining the window,\n"
16359 " and plbox for drawing the box.\n"
16360 "\n"
16361 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16362 "\n"
16363 " This function is used in example 1,3,9,13,14,19-22,29.\n"
16364 "\n"
16365 "\n"
16366 "\n"
16367 "SYNOPSIS:\n"
16368 "\n"
16369 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16370 "\n"
16371 "ARGUMENTS:\n"
16372 "\n"
16373 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16374 " world coordinates).\n"
16375 "\n"
16376 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16377 " world coordinates).\n"
16378 "\n"
16379 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16380 " coordinates).\n"
16381 "\n"
16382 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16383 " coordinates).\n"
16384 "\n"
16385 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16386 " scales will not be set, the user must set up the scale before\n"
16387 " calling plenv using plsvpa, plvasp or other.\n"
16388 " 0: the x and y axes are scaled independently to use as much of\n"
16389 " the screen as possible.\n"
16390 " 1: the scales of the x and y axes are made equal.\n"
16391 " 2: the axis of the x and y axes are made equal, and the plot\n"
16392 " box will be square.\n"
16393 "\n"
16394 "\n"
16395 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16396 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16397 " -1: draw box only.\n"
16398 " 0: draw box, ticks, and numeric tick labels.\n"
16399 " 1: also draw coordinate axes at x=0 and y=0.\n"
16400 " 2: also draw a grid at major tick positions in both\n"
16401 " coordinates.\n"
16402 " 3: also draw a grid at minor tick positions in both\n"
16403 " coordinates.\n"
16404 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16405 " have to be converted to logarithms separately.)\n"
16406 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16407 " have to be converted to logarithms separately.)\n"
16408 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16409 " have to be converted to logarithms separately.)\n"
16410 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16411 " have to be converted to logarithms separately.)\n"
16412 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16413 " have to be converted to logarithms separately.)\n"
16414 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16415 " have to be converted to logarithms separately.)\n"
16416 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16417 " have to be converted to logarithms separately.)\n"
16418 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16419 " have to be converted to logarithms separately.)\n"
16420 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16421 " and y data have to be converted to logarithms separately.)\n"
16422 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16423 " and y data have to be converted to logarithms separately.)\n"
16424 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16425 " and y data have to be converted to logarithms separately.)\n"
16426 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16427 " and y data have to be converted to logarithms separately.)\n"
16428 " 40: same as 0 except date / time x labels.\n"
16429 " 41: same as 1 except date / time x labels.\n"
16430 " 42: same as 2 except date / time x labels.\n"
16431 " 43: same as 3 except date / time x labels.\n"
16432 " 50: same as 0 except date / time y labels.\n"
16433 " 51: same as 1 except date / time y labels.\n"
16434 " 52: same as 2 except date / time y labels.\n"
16435 " 53: same as 3 except date / time y labels.\n"
16436 " 60: same as 0 except date / time x and y labels.\n"
16437 " 61: same as 1 except date / time x and y labels.\n"
16438 " 62: same as 2 except date / time x and y labels.\n"
16439 " 63: same as 3 except date / time x and y labels.\n"
16440 " 70: same as 0 except custom x and y labels.\n"
16441 " 71: same as 1 except custom x and y labels.\n"
16442 " 72: same as 2 except custom x and y labels.\n"
16443 " 73: same as 3 except custom x and y labels.\n"
16444 "\n"
16445 ""},
16446 { "plenv0", _wrap_plenv0, METH_VARARGS, "\n"
16447 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16448 "\n"
16449 "DESCRIPTION:\n"
16450 "\n"
16451 " Sets up plotter environment for simple graphs by calling pladv and\n"
16452 " setting up viewport and window to sensible default values. plenv0\n"
16453 " leaves a standard margin (left-hand margin of eight character heights,\n"
16454 " and a margin around the other three sides of five character heights)\n"
16455 " around most graphs for axis labels and a title. When these defaults\n"
16456 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16457 " plvasp for setting up the viewport, plwind for defining the window,\n"
16458 " and plbox for drawing the box.\n"
16459 "\n"
16460 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16461 "\n"
16462 " This function is used in example 21.\n"
16463 "\n"
16464 "\n"
16465 "\n"
16466 "SYNOPSIS:\n"
16467 "\n"
16468 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16469 "\n"
16470 "ARGUMENTS:\n"
16471 "\n"
16472 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16473 " world coordinates).\n"
16474 "\n"
16475 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16476 " world coordinates).\n"
16477 "\n"
16478 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16479 " coordinates).\n"
16480 "\n"
16481 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16482 " coordinates).\n"
16483 "\n"
16484 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16485 " scales will not be set, the user must set up the scale before\n"
16486 " calling plenv0 using plsvpa, plvasp or other.\n"
16487 " 0: the x and y axes are scaled independently to use as much of\n"
16488 " the screen as possible.\n"
16489 " 1: the scales of the x and y axes are made equal.\n"
16490 " 2: the axis of the x and y axes are made equal, and the plot\n"
16491 " box will be square.\n"
16492 "\n"
16493 "\n"
16494 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16495 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16496 " -1: draw box only.\n"
16497 " 0: draw box, ticks, and numeric tick labels.\n"
16498 " 1: also draw coordinate axes at x=0 and y=0.\n"
16499 " 2: also draw a grid at major tick positions in both\n"
16500 " coordinates.\n"
16501 " 3: also draw a grid at minor tick positions in both\n"
16502 " coordinates.\n"
16503 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16504 " have to be converted to logarithms separately.)\n"
16505 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16506 " have to be converted to logarithms separately.)\n"
16507 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16508 " have to be converted to logarithms separately.)\n"
16509 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16510 " have to be converted to logarithms separately.)\n"
16511 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16512 " have to be converted to logarithms separately.)\n"
16513 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16514 " have to be converted to logarithms separately.)\n"
16515 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16516 " have to be converted to logarithms separately.)\n"
16517 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16518 " have to be converted to logarithms separately.)\n"
16519 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16520 " and y data have to be converted to logarithms separately.)\n"
16521 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16522 " and y data have to be converted to logarithms separately.)\n"
16523 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16524 " and y data have to be converted to logarithms separately.)\n"
16525 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16526 " and y data have to be converted to logarithms separately.)\n"
16527 " 40: same as 0 except date / time x labels.\n"
16528 " 41: same as 1 except date / time x labels.\n"
16529 " 42: same as 2 except date / time x labels.\n"
16530 " 43: same as 3 except date / time x labels.\n"
16531 " 50: same as 0 except date / time y labels.\n"
16532 " 51: same as 1 except date / time y labels.\n"
16533 " 52: same as 2 except date / time y labels.\n"
16534 " 53: same as 3 except date / time y labels.\n"
16535 " 60: same as 0 except date / time x and y labels.\n"
16536 " 61: same as 1 except date / time x and y labels.\n"
16537 " 62: same as 2 except date / time x and y labels.\n"
16538 " 63: same as 3 except date / time x and y labels.\n"
16539 " 70: same as 0 except custom x and y labels.\n"
16540 " 71: same as 1 except custom x and y labels.\n"
16541 " 72: same as 2 except custom x and y labels.\n"
16542 " 73: same as 3 except custom x and y labels.\n"
16543 "\n"
16544 ""},
16545 { "pleop", _wrap_pleop, METH_NOARGS, "\n"
16546 "Eject current page\n"
16547 "\n"
16548 "DESCRIPTION:\n"
16549 "\n"
16550 " Clears the graphics screen of an interactive device, or ejects a page\n"
16551 " on a plotter. See plbop for more information.\n"
16552 "\n"
16553 " Redacted form: pleop()\n"
16554 "\n"
16555 " This function is used in example 2,14.\n"
16556 "\n"
16557 "\n"
16558 "\n"
16559 "SYNOPSIS:\n"
16560 "\n"
16561 "pleop()\n"
16562 "\n"
16563 ""},
16564 { "plerrx", _wrap_plerrx, METH_VARARGS, "\n"
16565 "Draw error bars in x direction\n"
16566 "\n"
16567 "DESCRIPTION:\n"
16568 "\n"
16569 " Draws a set of n error bars in x direction, the i'th error bar\n"
16570 " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16571 " of the error bars are of length equal to the minor tick length\n"
16572 " (settable using plsmin).\n"
16573 "\n"
16574 " Redacted form: General: plerrx(xmin, ymax, y)\n"
16575 "\n"
16576 "\n"
16577 " This function is used in example 29.\n"
16578 "\n"
16579 "\n"
16580 "\n"
16581 "SYNOPSIS:\n"
16582 "\n"
16583 "plerrx(n, xmin, xmax, y)\n"
16584 "\n"
16585 "ARGUMENTS:\n"
16586 "\n"
16587 " n (PLINT, input) : Number of error bars to draw.\n"
16588 "\n"
16589 " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16590 " of the left-hand endpoints of the error bars.\n"
16591 "\n"
16592 " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16593 " of the right-hand endpoints of the error bars.\n"
16594 "\n"
16595 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16596 " the error bars.\n"
16597 "\n"
16598 ""},
16599 { "plerry", _wrap_plerry, METH_VARARGS, "\n"
16600 "Draw error bars in the y direction\n"
16601 "\n"
16602 "DESCRIPTION:\n"
16603 "\n"
16604 " Draws a set of n error bars in the y direction, the i'th error bar\n"
16605 " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16606 " of the error bars are of length equal to the minor tick length\n"
16607 " (settable using plsmin).\n"
16608 "\n"
16609 " Redacted form: General: plerry(x, ymin, ymax)\n"
16610 "\n"
16611 "\n"
16612 " This function is used in example 29.\n"
16613 "\n"
16614 "\n"
16615 "\n"
16616 "SYNOPSIS:\n"
16617 "\n"
16618 "plerry(n, x, ymin, ymax)\n"
16619 "\n"
16620 "ARGUMENTS:\n"
16621 "\n"
16622 " n (PLINT, input) : Number of error bars to draw.\n"
16623 "\n"
16624 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16625 " the error bars.\n"
16626 "\n"
16627 " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16628 " of the lower endpoints of the error bars.\n"
16629 "\n"
16630 " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16631 " of the upper endpoints of the error bars.\n"
16632 "\n"
16633 ""},
16634 { "plfamadv", _wrap_plfamadv, METH_NOARGS, "\n"
16635 "Advance to the next family file on the next new page\n"
16636 "\n"
16637 "DESCRIPTION:\n"
16638 "\n"
16639 " Advance to the next family file on the next new page.\n"
16640 "\n"
16641 " Redacted form: plfamadv()\n"
16642 "\n"
16643 " This function is not used in any examples.\n"
16644 "\n"
16645 "\n"
16646 "\n"
16647 "SYNOPSIS:\n"
16648 "\n"
16649 "plfamadv()\n"
16650 "\n"
16651 ""},
16652 { "plfill", _wrap_plfill, METH_VARARGS, "\n"
16653 "Draw filled polygon\n"
16654 "\n"
16655 "DESCRIPTION:\n"
16656 "\n"
16657 " Fills the polygon defined by the n points (\n"
16658 " x[i],\n"
16659 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16660 " style is a solid fill. The routine will automatically close the\n"
16661 " polygon between the last and first vertices. If multiple closed\n"
16662 " polygons are passed in x and y then plfill will fill in between them.\n"
16663 "\n"
16664 " Redacted form: plfill(x,y)\n"
16665 "\n"
16666 " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16667 "\n"
16668 "\n"
16669 "\n"
16670 "SYNOPSIS:\n"
16671 "\n"
16672 "plfill(n, x, y)\n"
16673 "\n"
16674 "ARGUMENTS:\n"
16675 "\n"
16676 " n (PLINT, input) : Number of vertices in polygon.\n"
16677 "\n"
16678 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16679 " vertices.\n"
16680 "\n"
16681 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16682 " vertices.\n"
16683 "\n"
16684 ""},
16685 { "plfill3", _wrap_plfill3, METH_VARARGS, "\n"
16686 "Draw filled polygon in 3D\n"
16687 "\n"
16688 "DESCRIPTION:\n"
16689 "\n"
16690 " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16691 " vectors using the pattern defined by plpsty or plpat. The routine\n"
16692 " will automatically close the polygon between the last and first\n"
16693 " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16694 " plfill3 will fill in between them.\n"
16695 "\n"
16696 " Redacted form: General: plfill3(x, y, z)\n"
16697 "\n"
16698 "\n"
16699 " This function is used in example 15.\n"
16700 "\n"
16701 "\n"
16702 "\n"
16703 "SYNOPSIS:\n"
16704 "\n"
16705 "plfill3(n, x, y, z)\n"
16706 "\n"
16707 "ARGUMENTS:\n"
16708 "\n"
16709 " n (PLINT, input) : Number of vertices in polygon.\n"
16710 "\n"
16711 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16712 " vertices.\n"
16713 "\n"
16714 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16715 " vertices.\n"
16716 "\n"
16717 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16718 " vertices.\n"
16719 "\n"
16720 ""},
16721 { "plgradient", _wrap_plgradient, METH_VARARGS, "\n"
16722 "Draw linear gradient inside polygon\n"
16723 "\n"
16724 "DESCRIPTION:\n"
16725 "\n"
16726 " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16727 " points (\n"
16728 " x[i],\n"
16729 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16730 " polygon coordinates and the gradient angle are all expressed in world\n"
16731 " coordinates. The angle from the x axis for both the rotated\n"
16732 " coordinate system and the gradient vector is specified by angle. The\n"
16733 " magnitude of the gradient vector is the difference between the maximum\n"
16734 " and minimum values of x for the vertices in the rotated coordinate\n"
16735 " system. The origin of the gradient vector can be interpreted as being\n"
16736 " anywhere on the line corresponding to the minimum x value for the\n"
16737 " vertices in the rotated coordinate system. The distance along the\n"
16738 " gradient vector is linearly transformed to the independent variable of\n"
16739 " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16740 " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16741 " color corresponding to the independent variable of cmap1. For more\n"
16742 " information about cmap1 (see the PLplot documentation).\n"
16743 "\n"
16744 " Redacted form: plgradient(x,y,angle)\n"
16745 "\n"
16746 " This function is used in examples 25 and 30.\n"
16747 "\n"
16748 "\n"
16749 "\n"
16750 "SYNOPSIS:\n"
16751 "\n"
16752 "plgradient(n, x, y, angle)\n"
16753 "\n"
16754 "ARGUMENTS:\n"
16755 "\n"
16756 " n (PLINT, input) : Number of vertices in polygon.\n"
16757 "\n"
16758 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16759 " vertices.\n"
16760 "\n"
16761 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16762 " vertices.\n"
16763 "\n"
16764 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16765 " axis.\n"
16766 "\n"
16767 ""},
16768 { "plflush", _wrap_plflush, METH_NOARGS, "\n"
16769 "Flushes the output stream\n"
16770 "\n"
16771 "DESCRIPTION:\n"
16772 "\n"
16773 " Flushes the output stream. Use sparingly, if at all.\n"
16774 "\n"
16775 " Redacted form: plflush()\n"
16776 "\n"
16777 " This function is used in examples 1 and 14.\n"
16778 "\n"
16779 "\n"
16780 "\n"
16781 "SYNOPSIS:\n"
16782 "\n"
16783 "plflush()\n"
16784 "\n"
16785 ""},
16786 { "plfont", _wrap_plfont, METH_O, "\n"
16787 "Set font\n"
16788 "\n"
16789 "DESCRIPTION:\n"
16790 "\n"
16791 " Sets the font used for subsequent text and symbols. For devices that\n"
16792 " still use Hershey fonts this routine has no effect unless the Hershey\n"
16793 " fonts with extended character set are loaded (see plfontld). For\n"
16794 " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16795 " this routine calls the plsfci routine with argument set up\n"
16796 " appropriately for the various cases below. However, this method of\n"
16797 " specifying the font for unicode-aware devices is deprecated, and the\n"
16798 " much more flexible method of calling plsfont directly is recommended\n"
16799 " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16800 "\n"
16801 " Redacted form: plfont(ifont)\n"
16802 "\n"
16803 " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16804 "\n"
16805 "\n"
16806 "\n"
16807 "SYNOPSIS:\n"
16808 "\n"
16809 "plfont(ifont)\n"
16810 "\n"
16811 "ARGUMENTS:\n"
16812 "\n"
16813 " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16814 " (simplest and fastest)\n"
16815 " 2: Serif font\n"
16816 " 3: Italic font\n"
16817 " 4: Script font\n"
16818 "\n"
16819 ""},
16820 { "plfontld", _wrap_plfontld, METH_O, "\n"
16821 "Load Hershey fonts\n"
16822 "\n"
16823 "DESCRIPTION:\n"
16824 "\n"
16825 " Loads the Hershey fonts used for text and symbols. This routine may\n"
16826 " be called before or after initializing PLplot. If not explicitly\n"
16827 " called before PLplot initialization, then by default that\n"
16828 " initialization loads Hershey fonts with the extended character set.\n"
16829 " This routine only has a practical effect for devices that still use\n"
16830 " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16831 " system fonts instead of Hershey fonts).\n"
16832 "\n"
16833 " Redacted form: plfontld(fnt)\n"
16834 "\n"
16835 " This function is used in examples 1 and 7.\n"
16836 "\n"
16837 "\n"
16838 "\n"
16839 "SYNOPSIS:\n"
16840 "\n"
16841 "plfontld(fnt)\n"
16842 "\n"
16843 "ARGUMENTS:\n"
16844 "\n"
16845 " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16846 " A zero value specifies Hershey fonts with the standard character\n"
16847 " set and a non-zero value (the default assumed if plfontld is never\n"
16848 " called) specifies Hershey fonts with the extended character set.\n"
16849 "\n"
16850 ""},
16851 { "plgchr", _wrap_plgchr, METH_NOARGS, "\n"
16852 "Get character default height and current (scaled) height\n"
16853 "\n"
16854 "DESCRIPTION:\n"
16855 "\n"
16856 " Get character default height and current (scaled) height.\n"
16857 "\n"
16858 " Redacted form: plgchr(p_def, p_ht)\n"
16859 "\n"
16860 " This function is used in example 23.\n"
16861 "\n"
16862 "\n"
16863 "\n"
16864 "SYNOPSIS:\n"
16865 "\n"
16866 "plgchr(p_def, p_ht)\n"
16867 "\n"
16868 "ARGUMENTS:\n"
16869 "\n"
16870 " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16871 " character height (mm).\n"
16872 "\n"
16873 " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16874 " character height (mm).\n"
16875 "\n"
16876 ""},
16877 { "plgcol0", _wrap_plgcol0, METH_O, "\n"
16878 "Returns 8-bit RGB values for given color index from cmap0\n"
16879 "\n"
16880 "DESCRIPTION:\n"
16881 "\n"
16882 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16883 " PLplot documentation). Values are negative if an invalid color id is\n"
16884 " given.\n"
16885 "\n"
16886 " Redacted form: plgcol0(icol0, r, g, b)\n"
16887 "\n"
16888 " This function is used in example 2.\n"
16889 "\n"
16890 "\n"
16891 "\n"
16892 "SYNOPSIS:\n"
16893 "\n"
16894 "plgcol0(icol0, r, g, b)\n"
16895 "\n"
16896 "ARGUMENTS:\n"
16897 "\n"
16898 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16899 "\n"
16900 " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16901 " value.\n"
16902 "\n"
16903 " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16904 " value.\n"
16905 "\n"
16906 " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16907 " value.\n"
16908 "\n"
16909 ""},
16910 { "plgcol0a", _wrap_plgcol0a, METH_O, "\n"
16911 "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16912 "\n"
16913 "DESCRIPTION:\n"
16914 "\n"
16915 " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16916 " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16917 " Values are negative if an invalid color id is given.\n"
16918 "\n"
16919 " Redacted form: plgcola(r, g, b)\n"
16920 "\n"
16921 " This function is used in example 30.\n"
16922 "\n"
16923 "\n"
16924 "\n"
16925 "SYNOPSIS:\n"
16926 "\n"
16927 "plgcol0a(icol0, r, g, b, alpha)\n"
16928 "\n"
16929 "ARGUMENTS:\n"
16930 "\n"
16931 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16932 "\n"
16933 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16934 " in the range from 0 to 255.\n"
16935 "\n"
16936 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16937 " in the range from 0 to 255.\n"
16938 "\n"
16939 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16940 " in the range from 0 to 255.\n"
16941 "\n"
16942 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16943 " transparency in the range from (0.0-1.0).\n"
16944 "\n"
16945 ""},
16946 { "plgcolbg", _wrap_plgcolbg, METH_NOARGS, "\n"
16947 "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16948 "\n"
16949 "DESCRIPTION:\n"
16950 "\n"
16951 " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16952 "\n"
16953 " Redacted form: plgcolbg(r, g, b)\n"
16954 "\n"
16955 " This function is used in example 31.\n"
16956 "\n"
16957 "\n"
16958 "\n"
16959 "SYNOPSIS:\n"
16960 "\n"
16961 "plgcolbg(r, g, b)\n"
16962 "\n"
16963 "ARGUMENTS:\n"
16964 "\n"
16965 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16966 " in the range from 0 to 255.\n"
16967 "\n"
16968 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16969 " in the range from 0 to 255.\n"
16970 "\n"
16971 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16972 " in the range from 0 to 255.\n"
16973 "\n"
16974 ""},
16975 { "plgcolbga", _wrap_plgcolbga, METH_NOARGS, "\n"
16976 "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
16977 "\n"
16978 "DESCRIPTION:\n"
16979 "\n"
16980 " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
16981 " alpha transparency value.\n"
16982 "\n"
16983 " This function is used in example 31.\n"
16984 "\n"
16985 "\n"
16986 "\n"
16987 "SYNOPSIS:\n"
16988 "\n"
16989 "plgcolbga(r, g, b, alpha)\n"
16990 "\n"
16991 "ARGUMENTS:\n"
16992 "\n"
16993 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16994 " in the range from 0 to 255.\n"
16995 "\n"
16996 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16997 " in the range from 0 to 255.\n"
16998 "\n"
16999 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17000 " in the range from 0 to 255.\n"
17001 "\n"
17002 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
17003 " transparency in the range (0.0-1.0).\n"
17004 "\n"
17005 ""},
17006 { "plgcompression", _wrap_plgcompression, METH_NOARGS, "\n"
17007 "Get the current device-compression setting\n"
17008 "\n"
17009 "DESCRIPTION:\n"
17010 "\n"
17011 " Get the current device-compression setting. This parameter is only\n"
17012 " used for drivers that provide compression.\n"
17013 "\n"
17014 " Redacted form: plgcompression(compression)\n"
17015 "\n"
17016 " This function is used in example 31.\n"
17017 "\n"
17018 "\n"
17019 "\n"
17020 "SYNOPSIS:\n"
17021 "\n"
17022 "plgcompression(compression)\n"
17023 "\n"
17024 "ARGUMENTS:\n"
17025 "\n"
17026 " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
17027 " compression setting for the current device.\n"
17028 "\n"
17029 ""},
17030 { "plgdev", _wrap_plgdev, METH_NOARGS, "\n"
17031 "Get the current device (keyword) name\n"
17032 "\n"
17033 "DESCRIPTION:\n"
17034 "\n"
17035 " Get the current device (keyword) name. Note: you must have allocated\n"
17036 " space for this (80 characters is safe).\n"
17037 "\n"
17038 " Redacted form: plgdev(p_dev)\n"
17039 "\n"
17040 " This function is used in example 14.\n"
17041 "\n"
17042 "\n"
17043 "\n"
17044 "SYNOPSIS:\n"
17045 "\n"
17046 "plgdev(p_dev)\n"
17047 "\n"
17048 "ARGUMENTS:\n"
17049 "\n"
17050 " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17051 " (with preallocated length of 80 characters or more) containing the\n"
17052 " device (keyword) name.\n"
17053 "\n"
17054 ""},
17055 { "plgdidev", _wrap_plgdidev, METH_NOARGS, "\n"
17056 "Get parameters that define current device-space window\n"
17057 "\n"
17058 "DESCRIPTION:\n"
17059 "\n"
17060 " Get relative margin width, aspect ratio, and relative justification\n"
17061 " that define current device-space window. If plsdidev has not been\n"
17062 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
17063 " p_jy will all be 0.\n"
17064 "\n"
17065 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17066 "\n"
17067 " This function is used in example 31.\n"
17068 "\n"
17069 "\n"
17070 "\n"
17071 "SYNOPSIS:\n"
17072 "\n"
17073 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17074 "\n"
17075 "ARGUMENTS:\n"
17076 "\n"
17077 " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17078 " margin width.\n"
17079 "\n"
17080 " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
17081 " ratio.\n"
17082 "\n"
17083 " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17084 " justification in x.\n"
17085 "\n"
17086 " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17087 " justification in y.\n"
17088 "\n"
17089 ""},
17090 { "plgdiori", _wrap_plgdiori, METH_NOARGS, "\n"
17091 "Get plot orientation\n"
17092 "\n"
17093 "DESCRIPTION:\n"
17094 "\n"
17095 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
17096 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
17097 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
17098 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
17099 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
17100 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
17101 " not been called the default value pointed to by p_rot will be 0.\n"
17102 "\n"
17103 " Redacted form: plgdiori(p_rot)\n"
17104 "\n"
17105 " This function is not used in any examples.\n"
17106 "\n"
17107 "\n"
17108 "\n"
17109 "SYNOPSIS:\n"
17110 "\n"
17111 "plgdiori(p_rot)\n"
17112 "\n"
17113 "ARGUMENTS:\n"
17114 "\n"
17115 " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
17116 " parameter.\n"
17117 "\n"
17118 ""},
17119 { "plgdiplt", _wrap_plgdiplt, METH_NOARGS, "\n"
17120 "Get parameters that define current plot-space window\n"
17121 "\n"
17122 "DESCRIPTION:\n"
17123 "\n"
17124 " Get relative minima and maxima that define current plot-space window.\n"
17125 " If plsdiplt has not been called the default values pointed to by\n"
17126 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
17127 "\n"
17128 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17129 "\n"
17130 " This function is used in example 31.\n"
17131 "\n"
17132 "\n"
17133 "\n"
17134 "SYNOPSIS:\n"
17135 "\n"
17136 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17137 "\n"
17138 "ARGUMENTS:\n"
17139 "\n"
17140 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17141 " minimum in x.\n"
17142 "\n"
17143 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17144 " minimum in y.\n"
17145 "\n"
17146 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17147 " maximum in x.\n"
17148 "\n"
17149 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17150 " maximum in y.\n"
17151 "\n"
17152 ""},
17153 { "plgfam", _wrap_plgfam, METH_NOARGS, "\n"
17154 "Get family file parameters\n"
17155 "\n"
17156 "DESCRIPTION:\n"
17157 "\n"
17158 " Gets information about current family file, if familying is enabled.\n"
17159 " See the PLplot documentation for more information.\n"
17160 "\n"
17161 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
17162 "\n"
17163 " This function is used in examples 14 and 31.\n"
17164 "\n"
17165 "\n"
17166 "\n"
17167 "SYNOPSIS:\n"
17168 "\n"
17169 "plgfam(p_fam, p_num, p_bmax)\n"
17170 "\n"
17171 "ARGUMENTS:\n"
17172 "\n"
17173 " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17174 " family flag value. If nonzero, familying is enabled for the\n"
17175 " current device.\n"
17176 "\n"
17177 " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17178 " family file number.\n"
17179 "\n"
17180 " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17181 " file size (in bytes) for a family file.\n"
17182 "\n"
17183 ""},
17184 { "plgfci", _wrap_plgfci, METH_NOARGS, "\n"
17185 "Get FCI (font characterization integer)\n"
17186 "\n"
17187 "DESCRIPTION:\n"
17188 "\n"
17189 " Gets information about the current font using the FCI approach. See\n"
17190 " the PLplot documentation for more information.\n"
17191 "\n"
17192 " Redacted form: plgfci(p_fci)\n"
17193 "\n"
17194 " This function is used in example 23.\n"
17195 "\n"
17196 "\n"
17197 "\n"
17198 "SYNOPSIS:\n"
17199 "\n"
17200 "plgfci(p_fci)\n"
17201 "\n"
17202 "ARGUMENTS:\n"
17203 "\n"
17204 " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
17205 " FCI value.\n"
17206 "\n"
17207 ""},
17208 { "plgfnam", _wrap_plgfnam, METH_NOARGS, "\n"
17209 "Get output file name\n"
17210 "\n"
17211 "DESCRIPTION:\n"
17212 "\n"
17213 " Gets the current output file name, if applicable.\n"
17214 "\n"
17215 " Redacted form: plgfnam(fnam)\n"
17216 "\n"
17217 " This function is used in example 31.\n"
17218 "\n"
17219 "\n"
17220 "\n"
17221 "SYNOPSIS:\n"
17222 "\n"
17223 "plgfnam(fnam)\n"
17224 "\n"
17225 "ARGUMENTS:\n"
17226 "\n"
17227 " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17228 " (with preallocated length of 80 characters or more) containing the\n"
17229 " file name.\n"
17230 "\n"
17231 ""},
17232 { "plgfont", _wrap_plgfont, METH_NOARGS, "\n"
17233 "Get family, style and weight of the current font\n"
17234 "\n"
17235 "DESCRIPTION:\n"
17236 "\n"
17237 " Gets information about current font. See the PLplot documentation for\n"
17238 " more information on font selection.\n"
17239 "\n"
17240 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17241 "\n"
17242 " This function is used in example 23.\n"
17243 "\n"
17244 "\n"
17245 "\n"
17246 "SYNOPSIS:\n"
17247 "\n"
17248 "plgfont(p_family, p_style, p_weight)\n"
17249 "\n"
17250 "ARGUMENTS:\n"
17251 "\n"
17252 " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17253 " font family. The available values are given by the PL_FCI_*\n"
17254 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17255 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17256 " p_family is NULL then the font family is not returned.\n"
17257 "\n"
17258 " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17259 " font style. The available values are given by the PL_FCI_*\n"
17260 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17261 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
17262 " style is not returned.\n"
17263 "\n"
17264 " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17265 " font weight. The available values are given by the PL_FCI_*\n"
17266 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17267 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17268 " returned.\n"
17269 "\n"
17270 ""},
17271 { "plglevel", _wrap_plglevel, METH_NOARGS, "\n"
17272 "Get the (current) run level\n"
17273 "\n"
17274 "DESCRIPTION:\n"
17275 "\n"
17276 " Get the (current) run level. Valid settings are: 0, uninitialized\n"
17277 " 1, initialized\n"
17278 " 2, viewport defined\n"
17279 " 3, world coordinates defined\n"
17280 "\n"
17281 "\n"
17282 " Redacted form: plglevel(p_level)\n"
17283 "\n"
17284 " This function is used in example 31.\n"
17285 "\n"
17286 "\n"
17287 "\n"
17288 "SYNOPSIS:\n"
17289 "\n"
17290 "plglevel(p_level)\n"
17291 "\n"
17292 "ARGUMENTS:\n"
17293 "\n"
17294 " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
17295 " level.\n"
17296 "\n"
17297 ""},
17298 { "plgpage", _wrap_plgpage, METH_NOARGS, "\n"
17299 "Get page parameters\n"
17300 "\n"
17301 "DESCRIPTION:\n"
17302 "\n"
17303 " Gets the current page configuration. The length and offset values are\n"
17304 " expressed in units that are specific to the current driver. For\n"
17305 " instance: screen drivers will usually interpret them as number of\n"
17306 " pixels, whereas printer drivers will usually use mm.\n"
17307 "\n"
17308 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17309 "\n"
17310 " This function is used in examples 14 and 31.\n"
17311 "\n"
17312 "\n"
17313 "\n"
17314 "SYNOPSIS:\n"
17315 "\n"
17316 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17317 "\n"
17318 "ARGUMENTS:\n"
17319 "\n"
17320 " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17321 " pixels/inch (DPI) in x.\n"
17322 "\n"
17323 " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17324 " pixels/inch (DPI) in y.\n"
17325 "\n"
17326 " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17327 " length.\n"
17328 "\n"
17329 " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17330 " length.\n"
17331 "\n"
17332 " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17333 " offset.\n"
17334 "\n"
17335 " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17336 " offset.\n"
17337 "\n"
17338 ""},
17339 { "plgra", _wrap_plgra, METH_NOARGS, "\n"
17340 "Switch to graphics screen\n"
17341 "\n"
17342 "DESCRIPTION:\n"
17343 "\n"
17344 " Sets an interactive device to graphics mode, used in conjunction with\n"
17345 " pltext to allow graphics and text to be interspersed. On a device\n"
17346 " which supports separate text and graphics windows, this command causes\n"
17347 " control to be switched to the graphics window. If already in graphics\n"
17348 " mode, this command is ignored. It is also ignored on devices which\n"
17349 " only support a single window or use a different method for shifting\n"
17350 " focus. See also pltext.\n"
17351 "\n"
17352 " Redacted form: plgra()\n"
17353 "\n"
17354 " This function is used in example 1.\n"
17355 "\n"
17356 "\n"
17357 "\n"
17358 "SYNOPSIS:\n"
17359 "\n"
17360 "plgra()\n"
17361 "\n"
17362 ""},
17363 { "plgriddata", _wrap_plgriddata, METH_VARARGS, "\n"
17364 "Grid data from irregularly sampled data\n"
17365 "\n"
17366 "DESCRIPTION:\n"
17367 "\n"
17368 " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
17369 " require data organized as a grid, i.e., with x sample point values\n"
17370 " independent of y coordinate and vice versa. This function takes\n"
17371 " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
17372 " vectors; reads the desired grid location from the input vectors\n"
17373 " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
17374 " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
17375 " interpolate the data to the grid is specified with the argument type\n"
17376 " which can have one parameter specified in argument data.\n"
17377 "\n"
17378 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17379 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17380 "\n"
17381 "\n"
17382 " This function is used in example 21.\n"
17383 "\n"
17384 "\n"
17385 "\n"
17386 "SYNOPSIS:\n"
17387 "\n"
17388 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17389 "\n"
17390 "ARGUMENTS:\n"
17391 "\n"
17392 " x (PLFLT_VECTOR, input) : The input x vector.\n"
17393 "\n"
17394 " y (PLFLT_VECTOR, input) : The input y vector.\n"
17395 "\n"
17396 " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
17397 " y[i], z[i] represents one data sample coordinate.\n"
17398 "\n"
17399 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17400 " vectors.\n"
17401 "\n"
17402 " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17403 " in the x direction. Usually xg has nptsx equally spaced values\n"
17404 " from the minimum to the maximum values of the x input vector.\n"
17405 "\n"
17406 " nptsx (PLINT, input) : The number of points in the xg vector.\n"
17407 "\n"
17408 " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17409 " in the y direction. Similar to the xg parameter.\n"
17410 "\n"
17411 " nptsy (PLINT, input) : The number of points in the yg vector.\n"
17412 "\n"
17413 " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
17414 " where data lies in the grid specified by xg and yg. Therefore the\n"
17415 " zg matrix must be dimensioned\n"
17416 " nptsx by\n"
17417 " nptsy.\n"
17418 "\n"
17419 " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17420 " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17421 " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17422 " GRID_NNI: Natural Neighbors Interpolation\n"
17423 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17424 " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17425 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17426 " Weighted\n"
17427 " For details of the algorithms read the source file plgridd.c.\n"
17428 "\n"
17429 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17430 " which can be specified through this argument. Currently, for\n"
17431 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17432 " use, the lower the value, the noisier (more local) the\n"
17433 " approximation is.\n"
17434 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17435 " range [1. .. 2.]. High values enable the usage of very thin\n"
17436 " triangles for interpolation, possibly resulting in error in\n"
17437 " the approximation.\n"
17438 " GRID_NNI, only weights greater than data will be accepted. If\n"
17439 " 0, all weights will be accepted.\n"
17440 "\n"
17441 ""},
17442 { "plgspa", _wrap_plgspa, METH_NOARGS, "\n"
17443 "Get current subpage parameters\n"
17444 "\n"
17445 "DESCRIPTION:\n"
17446 "\n"
17447 " Gets the size of the current subpage in millimeters measured from the\n"
17448 " bottom left hand corner of the output device page or screen. Can be\n"
17449 " used in conjunction with plsvpa for setting the size of a viewport in\n"
17450 " absolute coordinates (millimeters).\n"
17451 "\n"
17452 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17453 "\n"
17454 " This function is used in example 23.\n"
17455 "\n"
17456 "\n"
17457 "\n"
17458 "SYNOPSIS:\n"
17459 "\n"
17460 "plgspa(xmin, xmax, ymin, ymax)\n"
17461 "\n"
17462 "ARGUMENTS:\n"
17463 "\n"
17464 " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17465 " the left hand edge of the subpage in millimeters.\n"
17466 "\n"
17467 " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17468 " the right hand edge of the subpage in millimeters.\n"
17469 "\n"
17470 " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17471 " the bottom edge of the subpage in millimeters.\n"
17472 "\n"
17473 " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17474 " the top edge of the subpage in millimeters.\n"
17475 "\n"
17476 ""},
17477 { "plgstrm", _wrap_plgstrm, METH_NOARGS, "\n"
17478 "Get current stream number\n"
17479 "\n"
17480 "DESCRIPTION:\n"
17481 "\n"
17482 " Gets the number of the current output stream. See also plsstrm.\n"
17483 "\n"
17484 " Redacted form: plgstrm(p_strm)\n"
17485 "\n"
17486 " This function is used in example 1,20.\n"
17487 "\n"
17488 "\n"
17489 "\n"
17490 "SYNOPSIS:\n"
17491 "\n"
17492 "plgstrm(p_strm)\n"
17493 "\n"
17494 "ARGUMENTS:\n"
17495 "\n"
17496 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17497 " stream value.\n"
17498 "\n"
17499 ""},
17500 { "plgver", _wrap_plgver, METH_NOARGS, "\n"
17501 "Get the current library version number\n"
17502 "\n"
17503 "DESCRIPTION:\n"
17504 "\n"
17505 " Get the current library version number. Note: you must have allocated\n"
17506 " space for this (80 characters is safe).\n"
17507 "\n"
17508 " Redacted form: plgver(p_ver)\n"
17509 "\n"
17510 " This function is used in example 1.\n"
17511 "\n"
17512 "\n"
17513 "\n"
17514 "SYNOPSIS:\n"
17515 "\n"
17516 "plgver(p_ver)\n"
17517 "\n"
17518 "ARGUMENTS:\n"
17519 "\n"
17520 " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17521 " (with preallocated length of 80 characters or more) containing the\n"
17522 " PLplot version number.\n"
17523 "\n"
17524 ""},
17525 { "plgvpd", _wrap_plgvpd, METH_NOARGS, "\n"
17526 "Get viewport limits in normalized device coordinates\n"
17527 "\n"
17528 "DESCRIPTION:\n"
17529 "\n"
17530 " Get viewport limits in normalized device coordinates.\n"
17531 "\n"
17532 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17533 "\n"
17534 "\n"
17535 " This function is used in example 31.\n"
17536 "\n"
17537 "\n"
17538 "\n"
17539 "SYNOPSIS:\n"
17540 "\n"
17541 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17542 "\n"
17543 "ARGUMENTS:\n"
17544 "\n"
17545 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17546 " viewport limit of the normalized device coordinate in x.\n"
17547 "\n"
17548 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17549 " viewport limit of the normalized device coordinate in x.\n"
17550 "\n"
17551 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17552 " viewport limit of the normalized device coordinate in y.\n"
17553 "\n"
17554 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17555 " viewport limit of the normalized device coordinate in y.\n"
17556 "\n"
17557 ""},
17558 { "plgvpw", _wrap_plgvpw, METH_NOARGS, "\n"
17559 "Get viewport limits in world coordinates\n"
17560 "\n"
17561 "DESCRIPTION:\n"
17562 "\n"
17563 " Get viewport limits in world coordinates.\n"
17564 "\n"
17565 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17566 "\n"
17567 "\n"
17568 " This function is used in example 31.\n"
17569 "\n"
17570 "\n"
17571 "\n"
17572 "SYNOPSIS:\n"
17573 "\n"
17574 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17575 "\n"
17576 "ARGUMENTS:\n"
17577 "\n"
17578 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17579 " viewport limit of the world coordinate in x.\n"
17580 "\n"
17581 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17582 " viewport limit of the world coordinate in x.\n"
17583 "\n"
17584 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17585 " viewport limit of the world coordinate in y.\n"
17586 "\n"
17587 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17588 " viewport limit of the world coordinate in y.\n"
17589 "\n"
17590 ""},
17591 { "plgxax", _wrap_plgxax, METH_NOARGS, "\n"
17592 "Get x axis parameters\n"
17593 "\n"
17594 "DESCRIPTION:\n"
17595 "\n"
17596 " Returns current values of the p_digmax and p_digits flags for the x\n"
17597 " axis. p_digits is updated after the plot is drawn, so this routine\n"
17598 " should only be called after the call to plbox (or plbox3) is complete.\n"
17599 " See the PLplot documentation for more information.\n"
17600 "\n"
17601 " Redacted form: plgxax(p_digmax, p_digits)\n"
17602 "\n"
17603 " This function is used in example 31.\n"
17604 "\n"
17605 "\n"
17606 "\n"
17607 "SYNOPSIS:\n"
17608 "\n"
17609 "plgxax(p_digmax, p_digits)\n"
17610 "\n"
17611 "ARGUMENTS:\n"
17612 "\n"
17613 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17614 " number of digits for the x axis. If nonzero, the printed label\n"
17615 " has been switched to a floating-point representation when the\n"
17616 " number of digits exceeds this value.\n"
17617 "\n"
17618 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17619 " number of digits for the numeric labels (x axis) from the last\n"
17620 " plot.\n"
17621 "\n"
17622 ""},
17623 { "plgyax", _wrap_plgyax, METH_NOARGS, "\n"
17624 "Get y axis parameters\n"
17625 "\n"
17626 "DESCRIPTION:\n"
17627 "\n"
17628 " Identical to plgxax, except that arguments are flags for y axis. See\n"
17629 " the description of plgxax for more detail.\n"
17630 "\n"
17631 " Redacted form: plgyax(p_digmax, p_digits)\n"
17632 "\n"
17633 " This function is used in example 31.\n"
17634 "\n"
17635 "\n"
17636 "\n"
17637 "SYNOPSIS:\n"
17638 "\n"
17639 "plgyax(p_digmax, p_digits)\n"
17640 "\n"
17641 "ARGUMENTS:\n"
17642 "\n"
17643 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17644 " number of digits for the y axis. If nonzero, the printed label\n"
17645 " has been switched to a floating-point representation when the\n"
17646 " number of digits exceeds this value.\n"
17647 "\n"
17648 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17649 " number of digits for the numeric labels (y axis) from the last\n"
17650 " plot.\n"
17651 "\n"
17652 ""},
17653 { "plgzax", _wrap_plgzax, METH_NOARGS, "\n"
17654 "Get z axis parameters\n"
17655 "\n"
17656 "DESCRIPTION:\n"
17657 "\n"
17658 " Identical to plgxax, except that arguments are flags for z axis. See\n"
17659 " the description of plgxax for more detail.\n"
17660 "\n"
17661 " Redacted form: plgzax(p_digmax, p_digits)\n"
17662 "\n"
17663 " This function is used in example 31.\n"
17664 "\n"
17665 "\n"
17666 "\n"
17667 "SYNOPSIS:\n"
17668 "\n"
17669 "plgzax(p_digmax, p_digits)\n"
17670 "\n"
17671 "ARGUMENTS:\n"
17672 "\n"
17673 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17674 " number of digits for the z axis. If nonzero, the printed label\n"
17675 " has been switched to a floating-point representation when the\n"
17676 " number of digits exceeds this value.\n"
17677 "\n"
17678 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17679 " number of digits for the numeric labels (z axis) from the last\n"
17680 " plot.\n"
17681 "\n"
17682 ""},
17683 { "plhist", _wrap_plhist, METH_VARARGS, "\n"
17684 "Plot a histogram from unbinned data\n"
17685 "\n"
17686 "DESCRIPTION:\n"
17687 "\n"
17688 " Plots a histogram from n data points stored in the data vector. This\n"
17689 " routine bins the data into nbin bins equally spaced between datmin and\n"
17690 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17691 " opt allows, among other things, the histogram either to be plotted in\n"
17692 " an existing window or causes plhist to call plenv with suitable limits\n"
17693 " before plotting the histogram.\n"
17694 "\n"
17695 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17696 "\n"
17697 " This function is used in example 5.\n"
17698 "\n"
17699 "\n"
17700 "\n"
17701 "SYNOPSIS:\n"
17702 "\n"
17703 "plhist(n, data, datmin, datmax, nbin, opt)\n"
17704 "\n"
17705 "ARGUMENTS:\n"
17706 "\n"
17707 " n (PLINT, input) : Number of data points.\n"
17708 "\n"
17709 " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17710 " n data points.\n"
17711 "\n"
17712 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17713 "\n"
17714 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17715 "\n"
17716 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17717 " divide the interval xmin to xmax.\n"
17718 "\n"
17719 " opt (PLINT, input) : Is a combination of several flags:\n"
17720 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17721 " the histogram data, the outer bins are expanded to fill up the\n"
17722 " entire x-axis, data outside the given extremes are assigned to the\n"
17723 " outer bins and bins of zero height are simply drawn.\n"
17724 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17725 " to fit the histogram data, without this flag, plenv is called\n"
17726 " to set the world coordinates.\n"
17727 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17728 " extremes are not taken into account. This option should\n"
17729 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17730 " properly present the data.\n"
17731 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17732 " size as the ones inside.\n"
17733 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17734 " (there is a gap for such bins).\n"
17735 "\n"
17736 ""},
17737 { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, "\n"
17738 "Convert HLS color to RGB\n"
17739 "\n"
17740 "DESCRIPTION:\n"
17741 "\n"
17742 " Convert HLS color coordinates to RGB.\n"
17743 "\n"
17744 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17745 "\n"
17746 "\n"
17747 " This function is used in example 2.\n"
17748 "\n"
17749 "\n"
17750 "\n"
17751 "SYNOPSIS:\n"
17752 "\n"
17753 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17754 "\n"
17755 "ARGUMENTS:\n"
17756 "\n"
17757 " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17758 " cylinder.\n"
17759 "\n"
17760 " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17761 " the axis of the color cylinder.\n"
17762 "\n"
17763 " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17764 " the radius of the color cylinder.\n"
17765 "\n"
17766 " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17767 " (0.0-1.0) of the color.\n"
17768 "\n"
17769 " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17770 " intensity (0.0-1.0) of the color.\n"
17771 "\n"
17772 " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17773 " intensity (0.0-1.0) of the color.\n"
17774 "\n"
17775 ""},
17776 { "plinit", _wrap_plinit, METH_NOARGS, "\n"
17777 "Initialize PLplot\n"
17778 "\n"
17779 "DESCRIPTION:\n"
17780 "\n"
17781 " Initializing the plotting package. The program prompts for the device\n"
17782 " keyword or number of the desired output device. Hitting a RETURN in\n"
17783 " response to the prompt is the same as selecting the first device.\n"
17784 " plinit will issue no prompt if either the device was specified\n"
17785 " previously (via command line flag, the plsetopt function, or the\n"
17786 " plsdev function), or if only one device is enabled when PLplot is\n"
17787 " installed. If subpages have been specified, the output device is\n"
17788 " divided into nx by ny subpages, each of which may be used\n"
17789 " independently. If plinit is called again during a program, the\n"
17790 " previously opened file will be closed. The subroutine pladv is used\n"
17791 " to advance from one subpage to the next.\n"
17792 "\n"
17793 " Redacted form: plinit()\n"
17794 "\n"
17795 " This function is used in all of the examples.\n"
17796 "\n"
17797 "\n"
17798 "\n"
17799 "SYNOPSIS:\n"
17800 "\n"
17801 "plinit()\n"
17802 "\n"
17803 ""},
17804 { "pljoin", _wrap_pljoin, METH_VARARGS, "\n"
17805 "Draw a line between two points\n"
17806 "\n"
17807 "DESCRIPTION:\n"
17808 "\n"
17809 " Joins the point (\n"
17810 " x1,\n"
17811 " y1) to (\n"
17812 " x2,\n"
17813 " y2).\n"
17814 "\n"
17815 " Redacted form: pljoin(x1,y1,x2,y2)\n"
17816 "\n"
17817 " This function is used in examples 3 and 14.\n"
17818 "\n"
17819 "\n"
17820 "\n"
17821 "SYNOPSIS:\n"
17822 "\n"
17823 "pljoin(x1, y1, x2, y2)\n"
17824 "\n"
17825 "ARGUMENTS:\n"
17826 "\n"
17827 " x1 (PLFLT, input) : x coordinate of first point.\n"
17828 "\n"
17829 " y1 (PLFLT, input) : y coordinate of first point.\n"
17830 "\n"
17831 " x2 (PLFLT, input) : x coordinate of second point.\n"
17832 "\n"
17833 " y2 (PLFLT, input) : y coordinate of second point.\n"
17834 "\n"
17835 ""},
17836 { "pllab", _wrap_pllab, METH_VARARGS, "\n"
17837 "Simple routine to write labels\n"
17838 "\n"
17839 "DESCRIPTION:\n"
17840 "\n"
17841 " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17842 "\n"
17843 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17844 "\n"
17845 " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17846 "\n"
17847 "\n"
17848 "\n"
17849 "SYNOPSIS:\n"
17850 "\n"
17851 "pllab(xlabel, ylabel, tlabel)\n"
17852 "\n"
17853 "ARGUMENTS:\n"
17854 "\n"
17855 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17856 " the label for the x axis.\n"
17857 "\n"
17858 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17859 " the label for the y axis.\n"
17860 "\n"
17861 " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17862 " the title of the plot.\n"
17863 "\n"
17864 ""},
17865 { "pllegend", _wrap_pllegend, METH_VARARGS, "\n"
17866 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17867 "\n"
17868 "DESCRIPTION:\n"
17869 "\n"
17870 " Routine for creating a discrete plot legend with a plotted filled box,\n"
17871 " line, and/or line of symbols for each annotated legend entry. (See\n"
17872 " plcolorbar for similar functionality for creating continuous color\n"
17873 " bars.) The arguments of pllegend provide control over the location\n"
17874 " and size of the legend as well as the location and characteristics of\n"
17875 " the elements (most of which are optional) within that legend. The\n"
17876 " resulting legend is clipped at the boundaries of the current subpage.\n"
17877 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17878 " defined in the documentation of the position parameter.)\n"
17879 "\n"
17880 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17881 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17882 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17883 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17884 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17885 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17886 "\n"
17887 " This function is used in examples 4, 26, and 33.\n"
17888 "\n"
17889 "\n"
17890 "\n"
17891 "SYNOPSIS:\n"
17892 "\n"
17893 "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"
17894 "\n"
17895 "ARGUMENTS:\n"
17896 "\n"
17897 " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17898 " legend width in adopted coordinates. This quantity is calculated\n"
17899 " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17900 " the routine depending on nlegend and nrow), and the length\n"
17901 " (calculated internally) of the longest text string.\n"
17902 "\n"
17903 " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17904 " legend height in adopted coordinates. This quantity is calculated\n"
17905 " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17906 " the routine depending on nlegend and nrow).\n"
17907 "\n"
17908 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17909 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17910 " on the left of the legend and the plotted area on the right.\n"
17911 " Otherwise, put the text area on the right of the legend and the\n"
17912 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17913 " plot a (semitransparent) background for the legend. If the\n"
17914 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17915 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17916 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17917 " plot the resulting array of legend entries in row-major order.\n"
17918 " Otherwise, plot the legend entries in column-major order.\n"
17919 "\n"
17920 " position (PLINT, input) : position contains bits which control the\n"
17921 " overall position of the legend and the definition of the adopted\n"
17922 " coordinates used for positions just like what is done for the\n"
17923 " position argument for plcolorbar. However, note that the defaults\n"
17924 " for the position bits (see below) are different than the\n"
17925 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17926 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17927 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17928 " the 16 possible standard positions (the 4 corners and centers of\n"
17929 " the 4 sides for both the inside and outside cases) of the legend\n"
17930 " relative to the adopted coordinate system. The corner positions\n"
17931 " are specified by the appropriate combination of two of the\n"
17932 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17933 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17934 " value of one of those bits. The adopted coordinates are\n"
17935 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17936 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17937 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17938 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17939 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17940 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17941 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17942 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17943 "\n"
17944 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17945 " coordinates from the specified standard position of the legend.\n"
17946 " For positive x, the direction of motion away from the standard\n"
17947 " position is inward/outward from the standard corner positions or\n"
17948 " standard left or right positions if the\n"
17949 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17950 " For the standard top or bottom positions, the direction of motion\n"
17951 " is toward positive X.\n"
17952 "\n"
17953 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17954 " coordinates from the specified standard position of the legend.\n"
17955 " For positive y, the direction of motion away from the standard\n"
17956 " position is inward/outward from the standard corner positions or\n"
17957 " standard top or bottom positions if the\n"
17958 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17959 " the standard left or right positions, the direction of motion is\n"
17960 " toward positive Y.\n"
17961 "\n"
17962 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17963 " of the plot area (where the colored boxes, lines, and/or lines of\n"
17964 " symbols are drawn) of the legend.\n"
17965 "\n"
17966 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17967 " legend (PL_LEGEND_BACKGROUND).\n"
17968 "\n"
17969 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17970 " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17971 "\n"
17972 " bb_style (PLINT, input) : The pllsty style number for the\n"
17973 " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
17974 "\n"
17975 " nrow (PLINT, input) : The number of rows in the matrix used to\n"
17976 " render the\n"
17977 " nlegend legend entries. For internal transformations of\n"
17978 " nrow, see further remarks under\n"
17979 " nlegend.\n"
17980 "\n"
17981 " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
17982 " to render the\n"
17983 " nlegend legend entries. For internal transformations of\n"
17984 " ncolumn, see further remarks under\n"
17985 " nlegend.\n"
17986 "\n"
17987 " nlegend (PLINT, input) : Number of legend entries. The above\n"
17988 " nrow and\n"
17989 " ncolumn values are transformed internally to be consistent with\n"
17990 " nlegend. If either\n"
17991 " nrow or\n"
17992 " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
17993 " of\n"
17994 " nrow and\n"
17995 " ncolumn is less than\n"
17996 " nlegend, the smaller of the two (or\n"
17997 " nrow, if\n"
17998 " nrow ==\n"
17999 " ncolumn) is increased so the product is >=\n"
18000 " nlegend. Thus, for example, the common\n"
18001 " nrow = 0,\n"
18002 " ncolumn = 0 case is transformed internally to\n"
18003 " nrow =\n"
18004 " nlegend,\n"
18005 " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
18006 " column.\n"
18007 "\n"
18008 " opt_array (PLINT_VECTOR, input) : A vector of\n"
18009 " nlegend values of options to control each individual plotted area\n"
18010 " corresponding to a legend entry. If the\n"
18011 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
18012 " area. If the\n"
18013 " PL_LEGEND_COLOR_BOX,\n"
18014 " PL_LEGEND_LINE, and/or\n"
18015 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
18016 " entry is plotted with a colored box; a line; and/or a line of\n"
18017 " symbols.\n"
18018 "\n"
18019 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
18020 " area in units of character width.\n"
18021 "\n"
18022 " text_scale (PLFLT, input) : Character height scale for text\n"
18023 " annotations.\n"
18024 "\n"
18025 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
18026 " character height from one legend entry to the next.\n"
18027 "\n"
18028 " text_justification (PLFLT, input) : Justification parameter used\n"
18029 " for text justification. The most common values of\n"
18030 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
18031 " is left justified, centred, or right justified within the text\n"
18032 " area, but other values are allowed as well.\n"
18033 "\n"
18034 " text_colors (PLINT_VECTOR, input) : A vector containing\n"
18035 " nlegend cmap0 text colors.\n"
18036 "\n"
18037 " text (PLCHAR_MATRIX, input) : A vector of\n"
18038 " nlegend UTF-8 character strings containing the legend annotations.\n"
18039 "\n"
18040 " box_colors (PLINT_VECTOR, input) : A vector containing\n"
18041 " nlegend cmap0 colors for the discrete colored boxes (\n"
18042 " PL_LEGEND_COLOR_BOX).\n"
18043 "\n"
18044 " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
18045 " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
18046 " PL_LEGEND_COLOR_BOX).\n"
18047 "\n"
18048 " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
18049 " nlegend scales (units of fraction of character height) for the height\n"
18050 " of the discrete colored boxes (\n"
18051 " PL_LEGEND_COLOR_BOX).\n"
18052 "\n"
18053 " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18054 " nlegend line widths for the patterns specified by box_patterns (\n"
18055 " PL_LEGEND_COLOR_BOX).\n"
18056 "\n"
18057 " line_colors (PLINT_VECTOR, input) : A vector containing\n"
18058 " nlegend cmap0 line colors (\n"
18059 " PL_LEGEND_LINE).\n"
18060 "\n"
18061 " line_styles (PLINT_VECTOR, input) : A vector containing\n"
18062 " nlegend line styles (plsty indices) (\n"
18063 " PL_LEGEND_LINE).\n"
18064 "\n"
18065 " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18066 " nlegend line widths (\n"
18067 " PL_LEGEND_LINE).\n"
18068 "\n"
18069 " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
18070 " nlegend cmap0 symbol colors (\n"
18071 " PL_LEGEND_SYMBOL).\n"
18072 "\n"
18073 " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
18074 " nlegend scale values for the symbol height (\n"
18075 " PL_LEGEND_SYMBOL).\n"
18076 "\n"
18077 " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
18078 " nlegend numbers of symbols to be drawn across the width of the plotted\n"
18079 " area (\n"
18080 " PL_LEGEND_SYMBOL).\n"
18081 "\n"
18082 " symbols (PLCHAR_MATRIX, input) : A vector of\n"
18083 " nlegend UTF-8 character strings containing the legend symbols. (\n"
18084 " PL_LEGEND_SYMBOL).\n"
18085 "\n"
18086 ""},
18087 { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, "\n"
18088 "Plot color bar for image, shade or gradient plots\n"
18089 "\n"
18090 "DESCRIPTION:\n"
18091 "\n"
18092 " Routine for creating a continuous color bar for image, shade, or\n"
18093 " gradient plots. (See pllegend for similar functionality for creating\n"
18094 " legends with discrete elements). The arguments of plcolorbar provide\n"
18095 " control over the location and size of the color bar as well as the\n"
18096 " location and characteristics of the elements (most of which are\n"
18097 " optional) within that color bar. The resulting color bar is clipped\n"
18098 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
18099 " system used for some of the parameters is defined in the documentation\n"
18100 " of the position parameter.)\n"
18101 "\n"
18102 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
18103 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
18104 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
18105 " labels, axis_opts, ticks, sub_ticks, values)\n"
18106 "\n"
18107 " This function is used in examples 16 and 33.\n"
18108 "\n"
18109 "\n"
18110 "\n"
18111 "SYNOPSIS:\n"
18112 "\n"
18113 "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"
18114 "\n"
18115 "ARGUMENTS:\n"
18116 "\n"
18117 " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18118 " labelled and decorated color bar width in adopted coordinates.\n"
18119 "\n"
18120 " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18121 " labelled and decorated color bar height in adopted coordinates.\n"
18122 "\n"
18123 " opt (PLINT, input) : opt contains bits controlling the overall\n"
18124 " color bar. The orientation (direction of the maximum value) of\n"
18125 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
18126 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
18127 " specified, the default orientation is toward the top if the\n"
18128 " colorbar is placed on the left or right of the viewport or toward\n"
18129 " the right if the colorbar is placed on the top or bottom of the\n"
18130 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
18131 " (semitransparent) background for the color bar. If the\n"
18132 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
18133 " color bar. The type of color bar must be specified with one of\n"
18134 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
18135 " more than one of those bits is set only the first one in the above\n"
18136 " list is honored. The position of the (optional) label/title can be\n"
18137 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
18138 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
18139 " will be drawn. If more than one of this list of bits is specified,\n"
18140 " only the first one on the list is honored. End-caps for the color\n"
18141 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
18142 " If a particular color bar cap option is not specified then no cap\n"
18143 " will be drawn for that end. As a special case for\n"
18144 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
18145 " specified. If this option is provided then any tick marks and tick\n"
18146 " labels will be placed at the breaks between shaded segments. TODO:\n"
18147 " This should be expanded to support custom placement of tick marks\n"
18148 " and tick labels at custom value locations for any color bar type.\n"
18149 "\n"
18150 " position (PLINT, input) : position contains bits which control the\n"
18151 " overall position of the color bar and the definition of the\n"
18152 " adopted coordinates used for positions just like what is done for\n"
18153 " the position argument for pllegend. However, note that the\n"
18154 " defaults for the position bits (see below) are different than the\n"
18155 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
18156 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
18157 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
18158 " the 16 possible standard positions (the 4 corners and centers of\n"
18159 " the 4 sides for both the inside and outside cases) of the color\n"
18160 " bar relative to the adopted coordinate system. The corner\n"
18161 " positions are specified by the appropriate combination of two of\n"
18162 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
18163 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
18164 " value of one of those bits. The adopted coordinates are\n"
18165 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
18166 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
18167 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
18168 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
18169 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
18170 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
18171 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
18172 " PL_POSITION_VIEWPORT.\n"
18173 "\n"
18174 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
18175 " coordinates from the specified standard position of the color bar.\n"
18176 " For positive x, the direction of motion away from the standard\n"
18177 " position is inward/outward from the standard corner positions or\n"
18178 " standard left or right positions if the\n"
18179 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18180 " For the standard top or bottom positions, the direction of motion\n"
18181 " is toward positive X.\n"
18182 "\n"
18183 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
18184 " coordinates from the specified standard position of the color bar.\n"
18185 " For positive y, the direction of motion away from the standard\n"
18186 " position is inward/outward from the standard corner positions or\n"
18187 " standard top or bottom positions if the\n"
18188 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18189 " For the standard left or right positions, the direction of motion\n"
18190 " is toward positive Y.\n"
18191 "\n"
18192 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
18193 " the X direction in adopted coordinates.\n"
18194 "\n"
18195 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
18196 " the Y direction in adopted coordinates.\n"
18197 "\n"
18198 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18199 " color bar (PL_COLORBAR_BACKGROUND).\n"
18200 "\n"
18201 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18202 " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
18203 "\n"
18204 " bb_style (PLINT, input) : The pllsty style number for the\n"
18205 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
18206 "\n"
18207 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
18208 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
18209 "\n"
18210 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
18211 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
18212 "\n"
18213 " cont_color (PLINT, input) : The cmap0 contour color for\n"
18214 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
18215 " it will be interpreted according to the design of plshades.\n"
18216 "\n"
18217 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18218 " plots. This is passed directly to plshades, so it will be\n"
18219 " interpreted according to the design of plshades.\n"
18220 "\n"
18221 " n_labels (PLINT, input) : Number of labels to place around the\n"
18222 " color bar.\n"
18223 "\n"
18224 " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
18225 " n_labels labels.\n"
18226 "\n"
18227 " labels (PLCHAR_MATRIX, input) : A vector of\n"
18228 " n_labels UTF-8 character strings containing the labels for the color\n"
18229 " bar. Ignored if no label position is specified with one of the\n"
18230 " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18231 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18232 " corresponding label_opts field.\n"
18233 "\n"
18234 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18235 " value must be greater than 0. It is typically 1 (numerical axis\n"
18236 " labels are provided for one of the long edges of the color bar),\n"
18237 " but it can be larger if multiple numerical axis labels for the\n"
18238 " long edges of the color bar are desired.\n"
18239 "\n"
18240 " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
18241 " n_axes ascii character strings containing options (interpreted as for\n"
18242 " plbox) for the color bar's axis definitions.\n"
18243 "\n"
18244 " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
18245 " spacing of the major tick marks (interpreted as for plbox) for the\n"
18246 " color bar's axis definitions.\n"
18247 "\n"
18248 " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
18249 " number of subticks (interpreted as for plbox) for the color bar's\n"
18250 " axis definitions.\n"
18251 "\n"
18252 " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
18253 " elements in each of the n_axes rows of the values matrix.\n"
18254 "\n"
18255 " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
18256 " values for the data range represented by the color bar. For a row\n"
18257 " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
18258 " elements in the row is specified by n_values[i_axis]. For\n"
18259 " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
18260 " is 2, and the corresponding row elements of the values matrix are\n"
18261 " the minimum and maximum value represented by the colorbar. For\n"
18262 " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
18263 " of the values matrix is interpreted the same as the nlevel and\n"
18264 " clevel arguments of plshades.\n"
18265 "\n"
18266 ""},
18267 { "pllightsource", _wrap_pllightsource, METH_VARARGS, "\n"
18268 "Sets the 3D position of the light source\n"
18269 "\n"
18270 "DESCRIPTION:\n"
18271 "\n"
18272 " Sets the 3D position of the light source for use with plsurf3d and\n"
18273 " plsurf3dl\n"
18274 "\n"
18275 " Redacted form: pllightsource(x, y, z)\n"
18276 "\n"
18277 " This function is used in example 8.\n"
18278 "\n"
18279 "\n"
18280 "\n"
18281 "SYNOPSIS:\n"
18282 "\n"
18283 "pllightsource(x, y, z)\n"
18284 "\n"
18285 "ARGUMENTS:\n"
18286 "\n"
18287 " x (PLFLT, input) : X-coordinate of the light source.\n"
18288 "\n"
18289 " y (PLFLT, input) : Y-coordinate of the light source.\n"
18290 "\n"
18291 " z (PLFLT, input) : Z-coordinate of the light source.\n"
18292 "\n"
18293 ""},
18294 { "plline", _wrap_plline, METH_VARARGS, "\n"
18295 "Draw a line\n"
18296 "\n"
18297 "DESCRIPTION:\n"
18298 "\n"
18299 " Draws line defined by n points in x and y.\n"
18300 "\n"
18301 " Redacted form: plline(x, y)\n"
18302 "\n"
18303 " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
18304 " 25-27, and 29.\n"
18305 "\n"
18306 "\n"
18307 "\n"
18308 "SYNOPSIS:\n"
18309 "\n"
18310 "plline(n, x, y)\n"
18311 "\n"
18312 "ARGUMENTS:\n"
18313 "\n"
18314 " n (PLINT, input) : Number of points defining line.\n"
18315 "\n"
18316 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18317 " points.\n"
18318 "\n"
18319 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18320 " points.\n"
18321 "\n"
18322 ""},
18323 { "plline3", _wrap_plline3, METH_VARARGS, "\n"
18324 "Draw a line in 3 space\n"
18325 "\n"
18326 "DESCRIPTION:\n"
18327 "\n"
18328 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18329 " first set up the viewport, the 2d viewing window (in world\n"
18330 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18331 " more info.\n"
18332 "\n"
18333 " Redacted form: plline3(x, y, z)\n"
18334 "\n"
18335 " This function is used in example 18.\n"
18336 "\n"
18337 "\n"
18338 "\n"
18339 "SYNOPSIS:\n"
18340 "\n"
18341 "plline3(n, x, y, z)\n"
18342 "\n"
18343 "ARGUMENTS:\n"
18344 "\n"
18345 " n (PLINT, input) : Number of points defining line.\n"
18346 "\n"
18347 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18348 " points.\n"
18349 "\n"
18350 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18351 " points.\n"
18352 "\n"
18353 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18354 " points.\n"
18355 "\n"
18356 ""},
18357 { "pllsty", _wrap_pllsty, METH_O, "\n"
18358 "Select line style\n"
18359 "\n"
18360 "DESCRIPTION:\n"
18361 "\n"
18362 " This sets the line style according to one of eight predefined patterns\n"
18363 " (also see plstyl).\n"
18364 "\n"
18365 " Redacted form: pllsty(lin)\n"
18366 "\n"
18367 " This function is used in examples 9, 12, 22, and 25.\n"
18368 "\n"
18369 "\n"
18370 "\n"
18371 "SYNOPSIS:\n"
18372 "\n"
18373 "pllsty(lin)\n"
18374 "\n"
18375 "ARGUMENTS:\n"
18376 "\n"
18377 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18378 " a continuous line, line style 2 is a line with short dashes and\n"
18379 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18380 " 4 has long dashes and short gaps and so on.\n"
18381 "\n"
18382 ""},
18383 { "plmesh", _wrap_plmesh, METH_VARARGS, "\n"
18384 "Plot surface mesh\n"
18385 "\n"
18386 "DESCRIPTION:\n"
18387 "\n"
18388 " Plots a surface mesh within the environment set up by plw3d. The\n"
18389 " surface is defined by the matrix z[\n"
18390 " nx][\n"
18391 " ny] , the point z[i][j] being the value of the function at (\n"
18392 " x[i],\n"
18393 " y[j]). Note that the points in vectors x and y do not need to be\n"
18394 " equally spaced, but must be stored in ascending order. The parameter\n"
18395 " opt controls the way in which the surface is displayed. For further\n"
18396 " details see the PLplot documentation.\n"
18397 "\n"
18398 " Redacted form: plmesh(x, y, z, opt)\n"
18399 "\n"
18400 " This function is used in example 11.\n"
18401 "\n"
18402 "\n"
18403 "\n"
18404 "SYNOPSIS:\n"
18405 "\n"
18406 "plmesh(x, y, z, nx, ny, opt)\n"
18407 "\n"
18408 "ARGUMENTS:\n"
18409 "\n"
18410 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18411 " which the function is evaluated.\n"
18412 "\n"
18413 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18414 " which the function is evaluated.\n"
18415 "\n"
18416 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18417 " plot. Should have dimensions of\n"
18418 " nx by\n"
18419 " ny.\n"
18420 "\n"
18421 " nx (PLINT, input) : Number of x values at which function has been\n"
18422 " evaluated.\n"
18423 "\n"
18424 " ny (PLINT, input) : Number of y values at which function has been\n"
18425 " evaluated.\n"
18426 "\n"
18427 " opt (PLINT, input) : Determines the way in which the surface is\n"
18428 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18429 " function of x for each value of y[j] .\n"
18430 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18431 " for each value of x[i] .\n"
18432 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18433 " at which function is defined.\n"
18434 "\n"
18435 ""},
18436 { "plmeshc", _wrap_plmeshc, METH_VARARGS, "\n"
18437 "Magnitude colored plot surface mesh with contour\n"
18438 "\n"
18439 "DESCRIPTION:\n"
18440 "\n"
18441 " A more powerful form of plmesh: the surface mesh can be colored\n"
18442 " accordingly to the current z value being plotted, a contour plot can\n"
18443 " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18444 " plotted function border and the base XY plane.\n"
18445 "\n"
18446 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18447 "\n"
18448 " This function is used in example 11.\n"
18449 "\n"
18450 "\n"
18451 "\n"
18452 "SYNOPSIS:\n"
18453 "\n"
18454 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18455 "\n"
18456 "ARGUMENTS:\n"
18457 "\n"
18458 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18459 " which the function is evaluated.\n"
18460 "\n"
18461 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18462 " which the function is evaluated.\n"
18463 "\n"
18464 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18465 " plot. Should have dimensions of\n"
18466 " nx by\n"
18467 " ny.\n"
18468 "\n"
18469 " nx (PLINT, input) : Number of x values at which function is\n"
18470 " evaluated.\n"
18471 "\n"
18472 " ny (PLINT, input) : Number of y values at which function is\n"
18473 " evaluated.\n"
18474 "\n"
18475 " opt (PLINT, input) : Determines the way in which the surface is\n"
18476 " represented. To specify more than one option just add the options,\n"
18477 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18478 " showing z as a function of x for each value of y[j] .\n"
18479 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18480 " for each value of x[i] .\n"
18481 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18482 " at which function is defined.\n"
18483 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18484 " the z value being plotted. The color is used from the current\n"
18485 " cmap1.\n"
18486 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18487 " using parameters\n"
18488 " nlevel and\n"
18489 " clevel.\n"
18490 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18491 " the borders of the plotted function.\n"
18492 "\n"
18493 "\n"
18494 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18495 " levels.\n"
18496 "\n"
18497 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18498 "\n"
18499 ""},
18500 { "plmkstrm", _wrap_plmkstrm, METH_NOARGS, "\n"
18501 "Creates a new stream and makes it the default\n"
18502 "\n"
18503 "DESCRIPTION:\n"
18504 "\n"
18505 " Creates a new stream and makes it the default. Differs from using\n"
18506 " plsstrm, in that a free stream number is found, and returned.\n"
18507 " Unfortunately, I have to start at stream 1 and work upward, since\n"
18508 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18509 " that no initial, library-opening call is required. So stream 0 must\n"
18510 " be preallocated, and there is no simple way of determining whether it\n"
18511 " is already in use or not.\n"
18512 "\n"
18513 " Redacted form: plmkstrm(p_strm)\n"
18514 "\n"
18515 " This function is used in examples 1 and 20.\n"
18516 "\n"
18517 "\n"
18518 "\n"
18519 "SYNOPSIS:\n"
18520 "\n"
18521 "plmkstrm(p_strm)\n"
18522 "\n"
18523 "ARGUMENTS:\n"
18524 "\n"
18525 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18526 " number of the created stream.\n"
18527 "\n"
18528 ""},
18529 { "plmtex", _wrap_plmtex, METH_VARARGS, "\n"
18530 "Write text relative to viewport boundaries\n"
18531 "\n"
18532 "DESCRIPTION:\n"
18533 "\n"
18534 " Writes text at a specified position relative to the viewport\n"
18535 " boundaries. Text may be written inside or outside the viewport, but\n"
18536 " is clipped at the subpage boundaries. The reference point of a string\n"
18537 " lies along a line passing through the string at half the height of a\n"
18538 " capital letter. The position of the reference point along this line\n"
18539 " is determined by just, and the position of the reference point\n"
18540 " relative to the viewport is set by disp and pos.\n"
18541 "\n"
18542 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18543 "\n"
18544 "\n"
18545 " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18546 " 26.\n"
18547 "\n"
18548 "\n"
18549 "\n"
18550 "SYNOPSIS:\n"
18551 "\n"
18552 "plmtex(side, disp, pos, just, text)\n"
18553 "\n"
18554 "ARGUMENTS:\n"
18555 "\n"
18556 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18557 " the side of the viewport along which the text is to be written.\n"
18558 " The string must be one of: b: Bottom of viewport, text written\n"
18559 " parallel to edge.\n"
18560 " bv: Bottom of viewport, text written at right angles to edge.\n"
18561 " l: Left of viewport, text written parallel to edge.\n"
18562 " lv: Left of viewport, text written at right angles to edge.\n"
18563 " r: Right of viewport, text written parallel to edge.\n"
18564 " rv: Right of viewport, text written at right angles to edge.\n"
18565 " t: Top of viewport, text written parallel to edge.\n"
18566 " tv: Top of viewport, text written at right angles to edge.\n"
18567 "\n"
18568 "\n"
18569 " disp (PLFLT, input) : Position of the reference point of string,\n"
18570 " measured outwards from the specified viewport edge in units of the\n"
18571 " current character height. Use negative disp to write within the\n"
18572 " viewport.\n"
18573 "\n"
18574 " pos (PLFLT, input) : Position of the reference point of string\n"
18575 " along the specified edge, expressed as a fraction of the length of\n"
18576 " the edge.\n"
18577 "\n"
18578 " just (PLFLT, input) : Specifies the position of the string relative\n"
18579 " to its reference point. If just=0. , the reference point is at\n"
18580 " the left and if just=1. , it is at the right of the string. Other\n"
18581 " values of just give intermediate justifications.\n"
18582 "\n"
18583 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18584 " written out.\n"
18585 "\n"
18586 ""},
18587 { "plmtex3", _wrap_plmtex3, METH_VARARGS, "\n"
18588 "Write text relative to viewport boundaries in 3D plots\n"
18589 "\n"
18590 "DESCRIPTION:\n"
18591 "\n"
18592 " Writes text at a specified position relative to the viewport\n"
18593 " boundaries. Text may be written inside or outside the viewport, but\n"
18594 " is clipped at the subpage boundaries. The reference point of a string\n"
18595 " lies along a line passing through the string at half the height of a\n"
18596 " capital letter. The position of the reference point along this line\n"
18597 " is determined by just, and the position of the reference point\n"
18598 " relative to the viewport is set by disp and pos.\n"
18599 "\n"
18600 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18601 "\n"
18602 " This function is used in example 28.\n"
18603 "\n"
18604 "\n"
18605 "\n"
18606 "SYNOPSIS:\n"
18607 "\n"
18608 "plmtex3(side, disp, pos, just, text)\n"
18609 "\n"
18610 "ARGUMENTS:\n"
18611 "\n"
18612 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18613 " the side of the viewport along which the text is to be written.\n"
18614 " The string should contain one or more of the following characters:\n"
18615 " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18616 " only label the X axis, not both the X and Y axes. x: Label the X\n"
18617 " axis.\n"
18618 " y: Label the Y axis.\n"
18619 " z: Label the Z axis.\n"
18620 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18621 " For X it is the axis that starts at y-min. For Y it is the\n"
18622 " axis that starts at x-min.\n"
18623 " s: Label the secondary axis.\n"
18624 " v: Draw the text perpendicular to the axis.\n"
18625 "\n"
18626 "\n"
18627 " disp (PLFLT, input) : Position of the reference point of string,\n"
18628 " measured outwards from the specified viewport edge in units of the\n"
18629 " current character height. Use negative disp to write within the\n"
18630 " viewport.\n"
18631 "\n"
18632 " pos (PLFLT, input) : Position of the reference point of string\n"
18633 " along the specified edge, expressed as a fraction of the length of\n"
18634 " the edge.\n"
18635 "\n"
18636 " just (PLFLT, input) : Specifies the position of the string relative\n"
18637 " to its reference point. If just=0. , the reference point is at\n"
18638 " the left and if just=1. , it is at the right of the string. Other\n"
18639 " values of just give intermediate justifications.\n"
18640 "\n"
18641 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18642 " written out.\n"
18643 "\n"
18644 ""},
18645 { "plot3d", _wrap_plot3d, METH_VARARGS, "\n"
18646 "Plot 3-d surface plot\n"
18647 "\n"
18648 "DESCRIPTION:\n"
18649 "\n"
18650 " Plots a three-dimensional surface plot within the environment set up\n"
18651 " by plw3d. The surface is defined by the matrix z[\n"
18652 " nx][\n"
18653 " ny] , the point z[i][j] being the value of the function at (\n"
18654 " x[i],\n"
18655 " y[j]). Note that the points in vectors x and y do not need to be\n"
18656 " equally spaced, but must be stored in ascending order. The parameter\n"
18657 " opt controls the way in which the surface is displayed. For further\n"
18658 " details see the PLplot documentation. The only difference between\n"
18659 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18660 " while plot3d only draws the surface as viewed from the top.\n"
18661 "\n"
18662 " Redacted form: plot3d(x, y, z, opt, side)\n"
18663 "\n"
18664 " This function is used in examples 11 and 21.\n"
18665 "\n"
18666 "\n"
18667 "\n"
18668 "SYNOPSIS:\n"
18669 "\n"
18670 "plot3d(x, y, z, nx, ny, opt, side)\n"
18671 "\n"
18672 "ARGUMENTS:\n"
18673 "\n"
18674 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18675 " which the function is evaluated.\n"
18676 "\n"
18677 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18678 " which the function is evaluated.\n"
18679 "\n"
18680 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18681 " plot. Should have dimensions of\n"
18682 " nx by\n"
18683 " ny.\n"
18684 "\n"
18685 " nx (PLINT, input) : Number of x values at which function is\n"
18686 " evaluated.\n"
18687 "\n"
18688 " ny (PLINT, input) : Number of y values at which function is\n"
18689 " evaluated.\n"
18690 "\n"
18691 " opt (PLINT, input) : Determines the way in which the surface is\n"
18692 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18693 " function of x for each value of y[j] .\n"
18694 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18695 " for each value of x[i] .\n"
18696 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18697 " at which function is defined.\n"
18698 "\n"
18699 "\n"
18700 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18701 " should be draw on the figure. If side is true sides are drawn,\n"
18702 " otherwise no sides are drawn.\n"
18703 "\n"
18704 ""},
18705 { "plot3dc", _wrap_plot3dc, METH_VARARGS, "\n"
18706 "Magnitude colored plot surface with contour\n"
18707 "\n"
18708 "DESCRIPTION:\n"
18709 "\n"
18710 " Aside from dropping the\n"
18711 " side functionality this is a more powerful form of plot3d: the surface\n"
18712 " mesh can be colored accordingly to the current z value being plotted,\n"
18713 " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18714 " drawn between the plotted function border and the base XY plane. The\n"
18715 " arguments are identical to those of plmeshc. The only difference\n"
18716 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18717 " the surface, while plot3dc only draws the surface as viewed from the\n"
18718 " top.\n"
18719 "\n"
18720 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18721 "\n"
18722 "\n"
18723 " This function is used in example 21.\n"
18724 "\n"
18725 "\n"
18726 "\n"
18727 "SYNOPSIS:\n"
18728 "\n"
18729 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18730 "\n"
18731 "ARGUMENTS:\n"
18732 "\n"
18733 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18734 " which the function is evaluated.\n"
18735 "\n"
18736 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18737 " which the function is evaluated.\n"
18738 "\n"
18739 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18740 " plot. Should have dimensions of\n"
18741 " nx by\n"
18742 " ny.\n"
18743 "\n"
18744 " nx (PLINT, input) : Number of x values at which function is\n"
18745 " evaluated.\n"
18746 "\n"
18747 " ny (PLINT, input) : Number of y values at which function is\n"
18748 " evaluated.\n"
18749 "\n"
18750 " opt (PLINT, input) : Determines the way in which the surface is\n"
18751 " represented. To specify more than one option just add the options,\n"
18752 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18753 " showing z as a function of x for each value of y[j] .\n"
18754 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18755 " for each value of x[i] .\n"
18756 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18757 " at which function is defined.\n"
18758 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18759 " the z value being plotted. The color is used from the current\n"
18760 " cmap1.\n"
18761 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18762 " using parameters\n"
18763 " nlevel and\n"
18764 " clevel.\n"
18765 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18766 " the borders of the plotted function.\n"
18767 "\n"
18768 "\n"
18769 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18770 " levels.\n"
18771 "\n"
18772 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18773 "\n"
18774 ""},
18775 { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, "\n"
18776 "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18777 "\n"
18778 "DESCRIPTION:\n"
18779 "\n"
18780 " When the implementation is completed this variant of plot3dc (see that\n"
18781 " function's documentation for more details) should be suitable for the\n"
18782 " case where the area of the x, y coordinate grid where z is defined can\n"
18783 " be non-rectangular. The implementation is incomplete so the last 4\n"
18784 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18785 " indexymax; are currently ignored and the functionality is otherwise\n"
18786 " identical to that of plot3dc.\n"
18787 "\n"
18788 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18789 " indexymin, indexymax)\n"
18790 "\n"
18791 "\n"
18792 " This function is not used in any example.\n"
18793 "\n"
18794 "\n"
18795 "\n"
18796 "SYNOPSIS:\n"
18797 "\n"
18798 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18799 "\n"
18800 "ARGUMENTS:\n"
18801 "\n"
18802 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18803 " which the function is evaluated.\n"
18804 "\n"
18805 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18806 " which the function is evaluated.\n"
18807 "\n"
18808 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18809 " plot. Should have dimensions of\n"
18810 " nx by\n"
18811 " ny.\n"
18812 "\n"
18813 " nx (PLINT, input) : Number of x values at which the function is\n"
18814 " evaluated.\n"
18815 "\n"
18816 " ny (PLINT, input) : Number of y values at which the function is\n"
18817 " evaluated.\n"
18818 "\n"
18819 " opt (PLINT, input) : Determines the way in which the surface is\n"
18820 " represented. To specify more than one option just add the options,\n"
18821 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18822 " showing z as a function of x for each value of y[j] .\n"
18823 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18824 " for each value of x[i] .\n"
18825 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18826 " at which function is defined.\n"
18827 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18828 " the z value being plotted. The color is used from the current\n"
18829 " cmap1.\n"
18830 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18831 " using parameters\n"
18832 " nlevel and\n"
18833 " clevel.\n"
18834 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18835 " the borders of the plotted function.\n"
18836 "\n"
18837 "\n"
18838 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18839 " levels.\n"
18840 "\n"
18841 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18842 "\n"
18843 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18844 " corresponds to the first x index where z is defined.\n"
18845 "\n"
18846 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18847 " which corresponds (by convention) to one more than the last x\n"
18848 " index value where z is defined.\n"
18849 "\n"
18850 " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18851 " values which all must be ≥ 0. These values are the first y index\n"
18852 " where z is defined for a particular x index in the range from\n"
18853 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18854 " indexxmax.\n"
18855 "\n"
18856 " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18857 " values which all must be ≤ ny. These values correspond (by\n"
18858 " convention) to one more than the last y index where z is defined\n"
18859 " for a particular x index in the range from indexxmin to indexxmax\n"
18860 " - 1. The dimension of indexymax is indexxmax.\n"
18861 "\n"
18862 ""},
18863 { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, "\n"
18864 "Plot shaded 3-d surface plot\n"
18865 "\n"
18866 "DESCRIPTION:\n"
18867 "\n"
18868 " Plots a three-dimensional shaded surface plot within the environment\n"
18869 " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18870 " z[\n"
18871 " nx][\n"
18872 " ny], the point z[i][j] being the value of the function at (\n"
18873 " x[i],\n"
18874 " y[j]). Note that the points in vectors x and y do not need to be\n"
18875 " equally spaced, but must be stored in ascending order. For further\n"
18876 " details see the PLplot documentation.\n"
18877 "\n"
18878 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18879 "\n"
18880 " This function is not used in any examples.\n"
18881 "\n"
18882 "\n"
18883 "\n"
18884 "SYNOPSIS:\n"
18885 "\n"
18886 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18887 "\n"
18888 "ARGUMENTS:\n"
18889 "\n"
18890 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18891 " which the function is evaluated.\n"
18892 "\n"
18893 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18894 " which the function is evaluated.\n"
18895 "\n"
18896 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18897 " plot. Should have dimensions of\n"
18898 " nx by\n"
18899 " ny.\n"
18900 "\n"
18901 " nx (PLINT, input) : Number of x values at which function is\n"
18902 " evaluated.\n"
18903 "\n"
18904 " ny (PLINT, input) : Number of y values at which function is\n"
18905 " evaluated.\n"
18906 "\n"
18907 " opt (PLINT, input) : Determines the way in which the surface is\n"
18908 " represented. To specify more than one option just add the options,\n"
18909 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18910 " connecting points at which function is defined.\n"
18911 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18912 " using parameters\n"
18913 " nlevel and\n"
18914 " clevel.\n"
18915 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18916 " using parameters\n"
18917 " nlevel and\n"
18918 " clevel.\n"
18919 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18920 " the borders of the plotted function.\n"
18921 " opt=MAG_COLOR : the surface is colored according to the value\n"
18922 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18923 " according to the intensity of the reflected light in the\n"
18924 " surface from a light source whose position is set using\n"
18925 " pllightsource.\n"
18926 "\n"
18927 "\n"
18928 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18929 " levels.\n"
18930 "\n"
18931 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18932 "\n"
18933 ""},
18934 { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, "\n"
18935 "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18936 "\n"
18937 "DESCRIPTION:\n"
18938 "\n"
18939 " This variant of plsurf3d (see that function's documentation for more\n"
18940 " details) should be suitable for the case where the area of the x, y\n"
18941 " coordinate grid where z is defined can be non-rectangular. The limits\n"
18942 " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18943 " indexymin, and indexymax.\n"
18944 "\n"
18945 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18946 " indexymax)\n"
18947 "\n"
18948 " This function is used in example 8.\n"
18949 "\n"
18950 "\n"
18951 "\n"
18952 "SYNOPSIS:\n"
18953 "\n"
18954 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18955 "\n"
18956 "ARGUMENTS:\n"
18957 "\n"
18958 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18959 " which the function is evaluated.\n"
18960 "\n"
18961 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18962 " which the function is evaluated.\n"
18963 "\n"
18964 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18965 " plot. Should have dimensions of\n"
18966 " nx by\n"
18967 " ny.\n"
18968 "\n"
18969 " nx (PLINT, input) : Number of x values at which function is\n"
18970 " evaluated.\n"
18971 "\n"
18972 " ny (PLINT, input) : Number of y values at which function is\n"
18973 " evaluated.\n"
18974 "\n"
18975 " opt (PLINT, input) : Determines the way in which the surface is\n"
18976 " represented. To specify more than one option just add the options,\n"
18977 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18978 " connecting points at which function is defined.\n"
18979 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18980 " using parameters\n"
18981 " nlevel and\n"
18982 " clevel.\n"
18983 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18984 " using parameters\n"
18985 " nlevel and\n"
18986 " clevel.\n"
18987 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18988 " the borders of the plotted function.\n"
18989 " opt=MAG_COLOR : the surface is colored according to the value\n"
18990 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18991 " according to the intensity of the reflected light in the\n"
18992 " surface from a light source whose position is set using\n"
18993 " pllightsource.\n"
18994 "\n"
18995 "\n"
18996 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18997 " levels.\n"
18998 "\n"
18999 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
19000 "\n"
19001 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
19002 " corresponds to the first x index where z is defined.\n"
19003 "\n"
19004 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
19005 " which corresponds (by convention) to one more than the last x\n"
19006 " index value where z is defined.\n"
19007 "\n"
19008 " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
19009 " values which all must be ≥ 0. These values are the first y index\n"
19010 " where z is defined for a particular x index in the range from\n"
19011 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
19012 " indexxmax.\n"
19013 "\n"
19014 " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
19015 " values which all must be ≤ ny. These values correspond (by\n"
19016 " convention) to one more than the last y index where z is defined\n"
19017 " for a particular x index in the range from indexxmin to indexxmax\n"
19018 " - 1. The dimension of indexymax is indexxmax.\n"
19019 "\n"
19020 ""},
19021 { "plparseopts", _wrap_plparseopts, METH_VARARGS, "\n"
19022 "Parse command-line arguments\n"
19023 "\n"
19024 "DESCRIPTION:\n"
19025 "\n"
19026 " Parse command-line arguments.\n"
19027 "\n"
19028 " plparseopts removes all recognized flags (decreasing argc\n"
19029 " accordingly), so that invalid input may be readily detected. It can\n"
19030 " also be used to process user command line flags. The user can merge\n"
19031 " an option table of type PLOptionTable into the internal option table\n"
19032 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
19033 " the external table(s) be parsed by calling plClearOpts before\n"
19034 " plMergeOpts.\n"
19035 "\n"
19036 " The default action taken by plparseopts is as follows:\n"
19037 " Returns with an error if an unrecognized option or badly formed\n"
19038 " option-value pair are encountered.\n"
19039 " Returns immediately (return code 0) when the first non-option command\n"
19040 " line argument is found.\n"
19041 " Returns with the return code of the option handler, if one was called.\n"
19042 "\n"
19043 " Deletes command line arguments from argv list as they are found, and\n"
19044 " decrements argc accordingly.\n"
19045 " Does not show \"invisible\" options in usage or help messages.\n"
19046 " Assumes the program name is contained in argv[0].\n"
19047 "\n"
19048 " These behaviors may be controlled through the\n"
19049 " mode argument.\n"
19050 "\n"
19051 " Redacted form: General: plparseopts(argv, mode)\n"
19052 "\n"
19053 "\n"
19054 " This function is used in all of the examples.\n"
19055 "\n"
19056 "\n"
19057 "\n"
19058 "SYNOPSIS:\n"
19059 "\n"
19060 "PLINT plparseopts(p_argc, argv, mode)\n"
19061 "\n"
19062 "ARGUMENTS:\n"
19063 "\n"
19064 " p_argc (int *, input/output) : Number of arguments.\n"
19065 "\n"
19066 " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
19067 " strings containing *p_argc command-line arguments.\n"
19068 "\n"
19069 " mode (PLINT, input) : Parsing mode with the following\n"
19070 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
19071 " and all error messages enabled, including program exit when an\n"
19072 " error occurs. Anything on the command line that isn't recognized\n"
19073 " as a valid option or option argument is flagged as an error.\n"
19074 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
19075 " of errors.\n"
19076 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
19077 " arguments.\n"
19078 " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
19079 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
19080 " pointer to the program name.\n"
19081 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
19082 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
19083 " unrecognized arguments.\n"
19084 "\n"
19085 ""},
19086 { "plpat", _wrap_plpat, METH_VARARGS, "\n"
19087 "Set area line fill pattern\n"
19088 "\n"
19089 "DESCRIPTION:\n"
19090 "\n"
19091 " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
19092 " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
19093 " inclinations and spacings. The arguments to this routine are the\n"
19094 " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
19095 " elements) specifying the inclinations in tenths of a degree and the\n"
19096 " spacing in micrometers. (See also plpsty)\n"
19097 "\n"
19098 " Redacted form: General: plpat(inc, del)\n"
19099 "\n"
19100 "\n"
19101 " This function is used in example 15.\n"
19102 "\n"
19103 "\n"
19104 "\n"
19105 "SYNOPSIS:\n"
19106 "\n"
19107 "plpat(nlin, inc, del)\n"
19108 "\n"
19109 "ARGUMENTS:\n"
19110 "\n"
19111 " nlin (PLINT, input) : Number of sets of lines making up the\n"
19112 " pattern, either 1 or 2.\n"
19113 "\n"
19114 " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19115 " inclination in tenths of a degree. (Should be between -900 and\n"
19116 " 900).\n"
19117 "\n"
19118 " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19119 " spacing in micrometers between the lines making up the pattern.\n"
19120 "\n"
19121 ""},
19122 { "plpath", _wrap_plpath, METH_VARARGS, "\n"
19123 "Draw a line between two points, accounting for coordinate transforms\n"
19124 "\n"
19125 "DESCRIPTION:\n"
19126 "\n"
19127 " Joins the point (\n"
19128 " x1,\n"
19129 " y1) to (\n"
19130 " x2,\n"
19131 " y2) . If a global coordinate transform is defined then the line is\n"
19132 " broken in to n segments to approximate the path. If no transform is\n"
19133 " defined then this simply acts like a call to pljoin.\n"
19134 "\n"
19135 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
19136 "\n"
19137 " This function is used in example 22.\n"
19138 "\n"
19139 "\n"
19140 "\n"
19141 "SYNOPSIS:\n"
19142 "\n"
19143 "plpath(n, x1, y1, x2, y2)\n"
19144 "\n"
19145 "ARGUMENTS:\n"
19146 "\n"
19147 " n (PLINT, input) : number of points to use to approximate the path.\n"
19148 "\n"
19149 " x1 (PLFLT, input) : x coordinate of first point.\n"
19150 "\n"
19151 " y1 (PLFLT, input) : y coordinate of first point.\n"
19152 "\n"
19153 " x2 (PLFLT, input) : x coordinate of second point.\n"
19154 "\n"
19155 " y2 (PLFLT, input) : y coordinate of second point.\n"
19156 "\n"
19157 ""},
19158 { "plpoin", _wrap_plpoin, METH_VARARGS, "\n"
19159 "Plot a glyph at the specified points\n"
19160 "\n"
19161 "DESCRIPTION:\n"
19162 "\n"
19163 " Plot a glyph at the specified points. (This function is largely\n"
19164 " superseded by plstring which gives access to many[!] more glyphs.)\n"
19165 " code=-1 means try to just draw a point. Right now it's just a move\n"
19166 " and a draw at the same place. Not ideal, since a sufficiently\n"
19167 " intelligent output device may optimize it away, or there may be faster\n"
19168 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19169 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19170 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19171 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19172 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19173 "\n"
19174 " Redacted form: plpoin(x, y, code)\n"
19175 "\n"
19176 " This function is used in examples 1, 6, 14, and 29.\n"
19177 "\n"
19178 "\n"
19179 "\n"
19180 "SYNOPSIS:\n"
19181 "\n"
19182 "plpoin(n, x, y, code)\n"
19183 "\n"
19184 "ARGUMENTS:\n"
19185 "\n"
19186 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19187 "\n"
19188 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19189 " points.\n"
19190 "\n"
19191 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19192 " points.\n"
19193 "\n"
19194 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19195 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19196 " each of the n points.\n"
19197 "\n"
19198 ""},
19199 { "plpoin3", _wrap_plpoin3, METH_VARARGS, "\n"
19200 "Plot a glyph at the specified 3D points\n"
19201 "\n"
19202 "DESCRIPTION:\n"
19203 "\n"
19204 " Plot a glyph at the specified 3D points. (This function is largely\n"
19205 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
19206 " Set up the call to this function similar to what is done for plline3.\n"
19207 " code=-1 means try to just draw a point. Right now it's just a move\n"
19208 " and a draw at the same place. Not ideal, since a sufficiently\n"
19209 " intelligent output device may optimize it away, or there may be faster\n"
19210 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19211 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19212 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19213 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19214 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19215 "\n"
19216 " Redacted form: plpoin3(x, y, z, code)\n"
19217 "\n"
19218 " This function is not used in any example.\n"
19219 "\n"
19220 "\n"
19221 "\n"
19222 "SYNOPSIS:\n"
19223 "\n"
19224 "plpoin3(n, x, y, z, code)\n"
19225 "\n"
19226 "ARGUMENTS:\n"
19227 "\n"
19228 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19229 "\n"
19230 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19231 " points.\n"
19232 "\n"
19233 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19234 " points.\n"
19235 "\n"
19236 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
19237 " points.\n"
19238 "\n"
19239 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19240 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19241 " each of the n points.\n"
19242 "\n"
19243 ""},
19244 { "plpoly3", _wrap_plpoly3, METH_VARARGS, "\n"
19245 "Draw a polygon in 3 space\n"
19246 "\n"
19247 "DESCRIPTION:\n"
19248 "\n"
19249 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19250 " like plline3, but differs from that function in that plpoly3 attempts\n"
19251 " to determine if the polygon is viewable depending on the order of the\n"
19252 " points within the vector and the value of ifcc. If the back of\n"
19253 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19254 " you want, then use plline3 instead.\n"
19255 "\n"
19256 " The points are assumed to be in a plane, and the directionality of the\n"
19257 " plane is determined from the first three points. Additional points do\n"
19258 " not have to lie on the plane defined by the first three, but if they\n"
19259 " do not, then the determination of visibility obviously can't be 100%\n"
19260 " accurate... So if you're 3 space polygons are too far from planar,\n"
19261 " consider breaking them into smaller polygons. 3 points define a plane\n"
19262 " :-).\n"
19263 "\n"
19264 " Bugs: If one of the first two segments is of zero length, or if they\n"
19265 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19266 " being correct. Avoid such situations :-). See x18c.c for an example\n"
19267 " of this problem. (Search for 20.1).\n"
19268 "\n"
19269 " Redacted form: plpoly3(x, y, z, code)\n"
19270 "\n"
19271 " This function is used in example 18.\n"
19272 "\n"
19273 "\n"
19274 "\n"
19275 "SYNOPSIS:\n"
19276 "\n"
19277 "plpoly3(n, x, y, z, draw, ifcc)\n"
19278 "\n"
19279 "ARGUMENTS:\n"
19280 "\n"
19281 " n (PLINT, input) : Number of points defining line.\n"
19282 "\n"
19283 " x (PLFLT_VECTOR, input) : A vector containing\n"
19284 " n x coordinates of points.\n"
19285 "\n"
19286 " y (PLFLT_VECTOR, input) : A vector containing\n"
19287 " n y coordinates of points.\n"
19288 "\n"
19289 " z (PLFLT_VECTOR, input) : A vector containing\n"
19290 " n z coordinates of points.\n"
19291 "\n"
19292 " draw (PLBOOL_VECTOR, input) : A vector containing\n"
19293 " n-1 Boolean values which control drawing the segments of the polygon.\n"
19294 " If draw[i] is true, then the polygon segment from index [i] to\n"
19295 " [i+1] is drawn, otherwise, not.\n"
19296 "\n"
19297 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19298 " polygon is determined by assuming the points are laid out in a\n"
19299 " counter-clockwise order. Otherwise, the directionality of the\n"
19300 " polygon is determined by assuming the points are laid out in a\n"
19301 " clockwise order.\n"
19302 "\n"
19303 ""},
19304 { "plprec", _wrap_plprec, METH_VARARGS, "\n"
19305 "Set precision in numeric labels\n"
19306 "\n"
19307 "DESCRIPTION:\n"
19308 "\n"
19309 " Sets the number of places after the decimal point in numeric labels.\n"
19310 "\n"
19311 " Redacted form: plprec(setp, prec)\n"
19312 "\n"
19313 " This function is used in example 29.\n"
19314 "\n"
19315 "\n"
19316 "\n"
19317 "SYNOPSIS:\n"
19318 "\n"
19319 "plprec(setp, prec)\n"
19320 "\n"
19321 "ARGUMENTS:\n"
19322 "\n"
19323 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19324 " automatically determines the number of places to use after the\n"
19325 " decimal point in numeric labels (like those used to label axes).\n"
19326 " If setp is 1 then prec sets the number of places.\n"
19327 "\n"
19328 " prec (PLINT, input) : The number of characters to draw after the\n"
19329 " decimal point in numeric labels.\n"
19330 "\n"
19331 ""},
19332 { "plpsty", _wrap_plpsty, METH_O, "\n"
19333 "Select area fill pattern\n"
19334 "\n"
19335 "DESCRIPTION:\n"
19336 "\n"
19337 " If\n"
19338 " patt is zero or less use either a hardware solid fill if the drivers\n"
19339 " have that capability (virtually all do) or fall back to a software\n"
19340 " emulation of a solid fill using the eighth area line fill pattern. If\n"
19341 " 0 <\n"
19342 " patt <= 8, then select one of eight predefined area line fill patterns\n"
19343 " to use (see plpat if you desire other patterns).\n"
19344 "\n"
19345 " Redacted form: plpsty(patt)\n"
19346 "\n"
19347 " This function is used in examples 12, 13, 15, 16, and 25.\n"
19348 "\n"
19349 "\n"
19350 "\n"
19351 "SYNOPSIS:\n"
19352 "\n"
19353 "plpsty(patt)\n"
19354 "\n"
19355 "ARGUMENTS:\n"
19356 "\n"
19357 " patt (PLINT, input) : The desired pattern index. If\n"
19358 " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
19359 " above) used. For\n"
19360 " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
19361 " line fill capability itself (most deliberately do not so that line\n"
19362 " fill patterns look identical for those drivers), the patterns\n"
19363 " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
19364 " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
19365 " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
19366 " (8) lines at both 45 degrees and -45 degrees.\n"
19367 "\n"
19368 ""},
19369 { "plptex", _wrap_plptex, METH_VARARGS, "\n"
19370 "Write text inside the viewport\n"
19371 "\n"
19372 "DESCRIPTION:\n"
19373 "\n"
19374 " Writes text at a specified position and inclination within the\n"
19375 " viewport. Text is clipped at the viewport boundaries. The reference\n"
19376 " point of a string lies along a line passing through the string at half\n"
19377 " the height of a capital letter. The position of the reference point\n"
19378 " along this line is determined by just, the reference point is placed\n"
19379 " at world coordinates (\n"
19380 " x,\n"
19381 " y) within the viewport. The inclination of the string is specified\n"
19382 " in terms of differences of world coordinates making it easy to write\n"
19383 " text parallel to a line in a graph.\n"
19384 "\n"
19385 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19386 "\n"
19387 " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
19388 "\n"
19389 "\n"
19390 "\n"
19391 "SYNOPSIS:\n"
19392 "\n"
19393 "plptex(x, y, dx, dy, just, text)\n"
19394 "\n"
19395 "ARGUMENTS:\n"
19396 "\n"
19397 " x (PLFLT, input) : x coordinate of reference point of string.\n"
19398 "\n"
19399 " y (PLFLT, input) : y coordinate of reference point of string.\n"
19400 "\n"
19401 " dx (PLFLT, input) : Together with dy, this specifies the\n"
19402 " inclination of the string. The baseline of the string is parallel\n"
19403 " to a line joining (\n"
19404 " x,\n"
19405 " y) to (\n"
19406 " x+\n"
19407 " dx,\n"
19408 " y+\n"
19409 " dy) .\n"
19410 "\n"
19411 " dy (PLFLT, input) : Together with dx, this specifies the\n"
19412 " inclination of the string.\n"
19413 "\n"
19414 " just (PLFLT, input) : Specifies the position of the string relative\n"
19415 " to its reference point. If just=0. , the reference point is at\n"
19416 " the left and if just=1. , it is at the right of the string. Other\n"
19417 " values of just give intermediate justifications.\n"
19418 "\n"
19419 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19420 " written out.\n"
19421 "\n"
19422 ""},
19423 { "plptex3", _wrap_plptex3, METH_VARARGS, "\n"
19424 "Write text inside the viewport of a 3D plot\n"
19425 "\n"
19426 "DESCRIPTION:\n"
19427 "\n"
19428 " Writes text at a specified position and inclination and with a\n"
19429 " specified shear within the viewport. Text is clipped at the viewport\n"
19430 " boundaries. The reference point of a string lies along a line passing\n"
19431 " through the string at half the height of a capital letter. The\n"
19432 " position of the reference point along this line is determined by just,\n"
19433 " and the reference point is placed at world coordinates (\n"
19434 " wx,\n"
19435 " wy,\n"
19436 " wz) within the viewport. The inclination and shear of the string is\n"
19437 " specified in terms of differences of world coordinates making it easy\n"
19438 " to write text parallel to a line in a graph.\n"
19439 "\n"
19440 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19441 "\n"
19442 " This function is used in example 28.\n"
19443 "\n"
19444 "\n"
19445 "\n"
19446 "SYNOPSIS:\n"
19447 "\n"
19448 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19449 "\n"
19450 "ARGUMENTS:\n"
19451 "\n"
19452 " wx (PLFLT, input) : x world coordinate of reference point of\n"
19453 " string.\n"
19454 "\n"
19455 " wy (PLFLT, input) : y world coordinate of reference point of\n"
19456 " string.\n"
19457 "\n"
19458 " wz (PLFLT, input) : z world coordinate of reference point of\n"
19459 " string.\n"
19460 "\n"
19461 " dx (PLFLT, input) : Together with dy and\n"
19462 " dz , this specifies the inclination of the string. The baseline of\n"
19463 " the string is parallel to a line joining (\n"
19464 " x,\n"
19465 " y,\n"
19466 " z) to (\n"
19467 " x+\n"
19468 " dx,\n"
19469 " y+\n"
19470 " dy,\n"
19471 " z+\n"
19472 " dz) .\n"
19473 "\n"
19474 " dy (PLFLT, input) : Together with dx and\n"
19475 " dz, this specifies the inclination of the string.\n"
19476 "\n"
19477 " dz (PLFLT, input) : Together with dx and\n"
19478 " dy, this specifies the inclination of the string.\n"
19479 "\n"
19480 " sx (PLFLT, input) : Together with sy and\n"
19481 " sz , this specifies the shear of the string. The string is sheared so\n"
19482 " that the characters are vertically parallel to a line joining (\n"
19483 " x,\n"
19484 " y,\n"
19485 " z) to (\n"
19486 " x+\n"
19487 " sx,\n"
19488 " y+\n"
19489 " sy,\n"
19490 " z+\n"
19491 " sz) . If sx =\n"
19492 " sy =\n"
19493 " sz = 0.) then the text is not sheared.\n"
19494 "\n"
19495 " sy (PLFLT, input) : Together with sx and\n"
19496 " sz, this specifies shear of the string.\n"
19497 "\n"
19498 " sz (PLFLT, input) : Together with sx and\n"
19499 " sy, this specifies shear of the string.\n"
19500 "\n"
19501 " just (PLFLT, input) : Specifies the position of the string relative\n"
19502 " to its reference point. If just=0. , the reference point is at\n"
19503 " the left and if just=1. , it is at the right of the string. Other\n"
19504 " values of just give intermediate justifications.\n"
19505 "\n"
19506 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19507 " written out.\n"
19508 "\n"
19509 ""},
19510 { "plrandd", _wrap_plrandd, METH_NOARGS, "\n"
19511 "Random number generator returning a real random number in the range [0,1]\n"
19512 "\n"
19513 "DESCRIPTION:\n"
19514 "\n"
19515 " Random number generator returning a real random number in the range\n"
19516 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19517 " / compilers provide their own random number generator, and so this is\n"
19518 " provided purely for convenience and to give a consistent random number\n"
19519 " generator across all languages supported by PLplot. This is\n"
19520 " particularly useful for comparing results from the test suite of\n"
19521 " examples.\n"
19522 "\n"
19523 " Redacted form: plrandd()\n"
19524 "\n"
19525 " This function is used in examples 17 and 21.\n"
19526 "\n"
19527 "\n"
19528 "\n"
19529 "SYNOPSIS:\n"
19530 "\n"
19531 "plrandd()\n"
19532 "\n"
19533 ""},
19534 { "plreplot", _wrap_plreplot, METH_NOARGS, "\n"
19535 "Replays contents of plot buffer to current device/file\n"
19536 "\n"
19537 "DESCRIPTION:\n"
19538 "\n"
19539 " Replays contents of plot buffer to current device/file.\n"
19540 "\n"
19541 " Redacted form: plreplot()\n"
19542 "\n"
19543 " This function is used in example 1,20.\n"
19544 "\n"
19545 "\n"
19546 "\n"
19547 "SYNOPSIS:\n"
19548 "\n"
19549 "plreplot()\n"
19550 "\n"
19551 ""},
19552 { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, "\n"
19553 "Convert RGB color to HLS\n"
19554 "\n"
19555 "DESCRIPTION:\n"
19556 "\n"
19557 " Convert RGB color coordinates to HLS\n"
19558 "\n"
19559 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19560 "\n"
19561 "\n"
19562 " This function is used in example 2.\n"
19563 "\n"
19564 "\n"
19565 "\n"
19566 "SYNOPSIS:\n"
19567 "\n"
19568 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19569 "\n"
19570 "ARGUMENTS:\n"
19571 "\n"
19572 " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19573 "\n"
19574 " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19575 "\n"
19576 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19577 "\n"
19578 " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19579 " degrees (0.0-360.0) on the color cylinder.\n"
19580 "\n"
19581 " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19582 " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19583 " cylinder.\n"
19584 "\n"
19585 " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19586 " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19587 " cylinder.\n"
19588 "\n"
19589 ""},
19590 { "plschr", _wrap_plschr, METH_VARARGS, "\n"
19591 "Set character size\n"
19592 "\n"
19593 "DESCRIPTION:\n"
19594 "\n"
19595 " This sets up the size of all subsequent characters drawn. The actual\n"
19596 " height of a character is the product of the default character size and\n"
19597 " a scaling factor.\n"
19598 "\n"
19599 " Redacted form: plschr(def, scale)\n"
19600 "\n"
19601 " This function is used in examples 2, 13, 23, and 24.\n"
19602 "\n"
19603 "\n"
19604 "\n"
19605 "SYNOPSIS:\n"
19606 "\n"
19607 "plschr(def, scale)\n"
19608 "\n"
19609 "ARGUMENTS:\n"
19610 "\n"
19611 " def (PLFLT, input) : The default height of a character in\n"
19612 " millimeters, should be set to zero if the default height is to\n"
19613 " remain unchanged. For rasterized drivers the dx and dy values\n"
19614 " specified in plspage are used to convert from mm to pixels (note\n"
19615 " the different unit systems used). This dpi aware scaling is not\n"
19616 " implemented for all drivers yet.\n"
19617 "\n"
19618 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19619 " actual character height.\n"
19620 "\n"
19621 ""},
19622 { "plscmap0", _wrap_plscmap0, METH_VARARGS, "\n"
19623 "Set cmap0 colors by 8-bit RGB values\n"
19624 "\n"
19625 "DESCRIPTION:\n"
19626 "\n"
19627 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19628 " documentation). This sets the entire color map -- only as many colors\n"
19629 " as specified will be allocated.\n"
19630 "\n"
19631 " Redacted form: plscmap0(r, g, b)\n"
19632 "\n"
19633 " This function is used in examples 2 and 24.\n"
19634 "\n"
19635 "\n"
19636 "\n"
19637 "SYNOPSIS:\n"
19638 "\n"
19639 "plscmap0(r, g, b, ncol0)\n"
19640 "\n"
19641 "ARGUMENTS:\n"
19642 "\n"
19643 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19644 " integers (0-255) representing the degree of red in the color.\n"
19645 "\n"
19646 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19647 " integers (0-255) representing the degree of green in the color.\n"
19648 "\n"
19649 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19650 " integers (0-255) representing the degree of blue in the color.\n"
19651 "\n"
19652 " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19653 "\n"
19654 ""},
19655 { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, "\n"
19656 "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19657 "\n"
19658 "DESCRIPTION:\n"
19659 "\n"
19660 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19661 " and PLFLT alpha transparency value. This sets the entire color map --\n"
19662 " only as many colors as specified will be allocated.\n"
19663 "\n"
19664 " Redacted form: plscmap0a(r, g, b, alpha)\n"
19665 "\n"
19666 " This function is used in examples 30.\n"
19667 "\n"
19668 "\n"
19669 "\n"
19670 "SYNOPSIS:\n"
19671 "\n"
19672 "plscmap0a(r, g, b, alpha, ncol0)\n"
19673 "\n"
19674 "ARGUMENTS:\n"
19675 "\n"
19676 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19677 " integers (0-255) representing the degree of red in the color.\n"
19678 "\n"
19679 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19680 " integers (0-255) representing the degree of green in the color.\n"
19681 "\n"
19682 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19683 " integers (0-255) representing the degree of blue in the color.\n"
19684 "\n"
19685 " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19686 " representing the alpha transparency of the color.\n"
19687 "\n"
19688 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19689 " vectors.\n"
19690 "\n"
19691 ""},
19692 { "plscmap0n", _wrap_plscmap0n, METH_O, "\n"
19693 "Set number of colors in cmap0\n"
19694 "\n"
19695 "DESCRIPTION:\n"
19696 "\n"
19697 " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19698 " (or reallocate) cmap0, and fill with default values for those colors\n"
19699 " not previously allocated. The first 16 default colors are given in\n"
19700 " the plcol0 documentation. For larger indices the default color is\n"
19701 " red.\n"
19702 "\n"
19703 " The drivers are not guaranteed to support more than 16 colors.\n"
19704 "\n"
19705 " Redacted form: plscmap0n(ncol0)\n"
19706 "\n"
19707 " This function is used in examples 15, 16, and 24.\n"
19708 "\n"
19709 "\n"
19710 "\n"
19711 "SYNOPSIS:\n"
19712 "\n"
19713 "plscmap0n(ncol0)\n"
19714 "\n"
19715 "ARGUMENTS:\n"
19716 "\n"
19717 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19718 " the cmap0 palette. If this number is zero or less, then the value\n"
19719 " from the previous call to plscmap0n is used and if there is no\n"
19720 " previous call, then a default value is used.\n"
19721 "\n"
19722 ""},
19723 { "plscmap1", _wrap_plscmap1, METH_VARARGS, "\n"
19724 "Set opaque RGB cmap1 colors values\n"
19725 "\n"
19726 "DESCRIPTION:\n"
19727 "\n"
19728 " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19729 " vector values. This function also sets the number of cmap1 colors.\n"
19730 " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19731 " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19732 " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19733 " to\n"
19734 " ncol1-1. So in order for this continuous color model to work\n"
19735 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19736 " that these RGB vectors are continuous functions of their integer\n"
19737 " indices.\n"
19738 "\n"
19739 " Redacted form: plscmap1(r, g, b)\n"
19740 "\n"
19741 " This function is used in example 31.\n"
19742 "\n"
19743 "\n"
19744 "\n"
19745 "SYNOPSIS:\n"
19746 "\n"
19747 "plscmap1(r, g, b, ncol1)\n"
19748 "\n"
19749 "ARGUMENTS:\n"
19750 "\n"
19751 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19752 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19753 " color as a continuous function of the integer index of the vector.\n"
19754 "\n"
19755 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19756 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19757 " color as a continuous function of the integer index of the vector.\n"
19758 "\n"
19759 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19760 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19761 " color as a continuous function of the integer index of the vector.\n"
19762 "\n"
19763 " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19764 "\n"
19765 ""},
19766 { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, "\n"
19767 "Set semitransparent cmap1 RGBA colors.\n"
19768 "\n"
19769 "DESCRIPTION:\n"
19770 "\n"
19771 " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19772 " RGBA vector values. This function also sets the number of cmap1\n"
19773 " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19774 " floating-point index in the range from 0.0-1.0 which is linearly\n"
19775 " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19776 " vectors in the range from 0 to\n"
19777 " ncol1-1. So in order for this continuous color model to work\n"
19778 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19779 " that these RGBA vectors are continuous functions of their integer\n"
19780 " indices.\n"
19781 "\n"
19782 " Redacted form: plscmap1a(r, g, b, alpha)\n"
19783 "\n"
19784 " This function is used in example 31.\n"
19785 "\n"
19786 "\n"
19787 "\n"
19788 "SYNOPSIS:\n"
19789 "\n"
19790 "plscmap1a(r, g, b, alpha, ncol1)\n"
19791 "\n"
19792 "ARGUMENTS:\n"
19793 "\n"
19794 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19795 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19796 " color as a continuous function of the integer index of the vector.\n"
19797 "\n"
19798 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19799 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19800 " color as a continuous function of the integer index of the vector.\n"
19801 "\n"
19802 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19803 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19804 " color as a continuous function of the integer index of the vector.\n"
19805 "\n"
19806 " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19807 " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19808 " completely transparent and 1.0 corresponds to completely opaque)\n"
19809 " the alpha transparency of the color as a continuous function of\n"
19810 " the integer index of the vector.\n"
19811 "\n"
19812 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19813 " vectors.\n"
19814 "\n"
19815 ""},
19816 { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, "\n"
19817 "Set cmap1 colors using a piece-wise linear relationship\n"
19818 "\n"
19819 "DESCRIPTION:\n"
19820 "\n"
19821 " Set cmap1 colors using a piece-wise linear relationship between the\n"
19822 " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19823 " (see the PLplot documentation). May be called at any time.\n"
19824 "\n"
19825 " The idea here is to specify a number of control points that define the\n"
19826 " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19827 " these points, linear interpolation is used which gives a smooth\n"
19828 " variation of color with intensity index. Any number of control points\n"
19829 " may be specified, located at arbitrary positions, although typically 2\n"
19830 " - 4 are enough. Another way of stating this is that we are traversing\n"
19831 " a given number of lines through HLS or RGB space as we move through\n"
19832 " cmap1 intensity indices. The control points at the minimum and\n"
19833 " maximum position (0 and 1) must always be specified. By adding more\n"
19834 " control points you can get more variation. One good technique for\n"
19835 " plotting functions that vary about some expected average is to use an\n"
19836 " additional 2 control points in the center (position ~= 0.5) that are\n"
19837 " the same lightness as the background (typically white for paper\n"
19838 " output, black for crt), and same hue as the boundary control points.\n"
19839 " This allows the highs and lows to be very easily distinguished.\n"
19840 "\n"
19841 " Each control point must specify the cmap1 intensity index and the\n"
19842 " associated three coordinates in HLS or RGB space. The first point\n"
19843 " must correspond to position = 0, and the last to position = 1.\n"
19844 "\n"
19845 " If RGB colors are provided then the interpolation takes place in RGB\n"
19846 " space and is trivial. However if HLS colors are provided then, because\n"
19847 " of the circular nature of the color wheel for the hue coordinate, the\n"
19848 " interpolation could be performed in either direction around the color\n"
19849 " wheel. The default behaviour is for the hue to be linearly\n"
19850 " interpolated ignoring this circular property of hue. So for example,\n"
19851 " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19852 " green and cyan. If instead you wish to interpolate the other way\n"
19853 " around the color wheel you have two options. You may provide hues\n"
19854 " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19855 " for red the interpolation will proceed via magenta. Alternatively you\n"
19856 " can utilise the alt_hue_path variable to reverse the direction of\n"
19857 " interpolation if you need to provide hues within the [0-360) range.\n"
19858 "\n"
19859 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19860 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19861 " -120]falsegreen-yellow-red-magenta-blue[240\n"
19862 " 480]falseblue-magenta-red-yellow-green[120\n"
19863 " 240]truegreen-yellow-red-magenta-blue[240\n"
19864 " 120]trueblue-magenta-red-yellow-green\n"
19865 "\n"
19866 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19867 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19868 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19869 "\n"
19870 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19871 " alt_hue_path)\n"
19872 "\n"
19873 " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19874 "\n"
19875 "\n"
19876 "\n"
19877 "SYNOPSIS:\n"
19878 "\n"
19879 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19880 "\n"
19881 "ARGUMENTS:\n"
19882 "\n"
19883 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19884 "\n"
19885 " npts (PLINT, input) : number of control points\n"
19886 "\n"
19887 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19888 " intensity index (0.0-1.0) in ascending order for each control\n"
19889 " point.\n"
19890 "\n"
19891 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19892 " coordinate (H or R) for each control point.\n"
19893 "\n"
19894 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19895 " coordinate (L or G) for each control point.\n"
19896 "\n"
19897 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19898 " coordinate (S or B) for each control point.\n"
19899 "\n"
19900 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19901 " npts - 1 elements), each containing either true to use the reversed\n"
19902 " HLS interpolation or false to use the regular HLS interpolation.\n"
19903 " (alt_hue_path[i] refers to the interpolation interval between the\n"
19904 " i and i + 1 control points). This parameter is not used for RGB\n"
19905 " colors (\n"
19906 " itype = true).\n"
19907 "\n"
19908 ""},
19909 { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, "\n"
19910 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19911 "\n"
19912 "DESCRIPTION:\n"
19913 "\n"
19914 " This is a variant of plscmap1l that supports alpha channel\n"
19915 " transparency. It sets cmap1 colors using a piece-wise linear\n"
19916 " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19917 " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19918 " transparency value (0.0-1.0). It may be called at any time.\n"
19919 "\n"
19920 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19921 " alpha, alt_hue_path)\n"
19922 "\n"
19923 " This function is used in example 30.\n"
19924 "\n"
19925 "\n"
19926 "\n"
19927 "SYNOPSIS:\n"
19928 "\n"
19929 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19930 "\n"
19931 "ARGUMENTS:\n"
19932 "\n"
19933 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19934 "\n"
19935 " npts (PLINT, input) : number of control points.\n"
19936 "\n"
19937 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19938 " intensity index (0.0-1.0) in ascending order for each control\n"
19939 " point.\n"
19940 "\n"
19941 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19942 " coordinate (H or R) for each control point.\n"
19943 "\n"
19944 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19945 " coordinate (L or G) for each control point.\n"
19946 "\n"
19947 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19948 " coordinate (S or B) for each control point.\n"
19949 "\n"
19950 " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19951 " transparency value (0.0-1.0) for each control point.\n"
19952 "\n"
19953 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19954 " npts - 1 elements) containing the alternative interpolation method\n"
19955 " Boolean value for each control point interval. (alt_hue_path[i]\n"
19956 " refers to the interpolation interval between the i and i + 1\n"
19957 " control points).\n"
19958 "\n"
19959 ""},
19960 { "plscmap1n", _wrap_plscmap1n, METH_O, "\n"
19961 "Set number of colors in cmap1\n"
19962 "\n"
19963 "DESCRIPTION:\n"
19964 "\n"
19965 " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19966 " values if this is the first allocation (see the PLplot documentation).\n"
19967 "\n"
19968 " Redacted form: plscmap1n(ncol1)\n"
19969 "\n"
19970 " This function is used in examples 8, 11, 20, and 21.\n"
19971 "\n"
19972 "\n"
19973 "\n"
19974 "SYNOPSIS:\n"
19975 "\n"
19976 "plscmap1n(ncol1)\n"
19977 "\n"
19978 "ARGUMENTS:\n"
19979 "\n"
19980 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19981 " the cmap1 palette. If this number is zero or less, then the value\n"
19982 " from the previous call to plscmap1n is used and if there is no\n"
19983 " previous call, then a default value is used.\n"
19984 "\n"
19985 ""},
19986 { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, "\n"
19987 "Set the cmap1 argument range for continuous color plots\n"
19988 "\n"
19989 "DESCRIPTION:\n"
19990 "\n"
19991 " Set the cmap1 argument range for continuous color plots that\n"
19992 " corresponds to the range of data values. The maximum range\n"
19993 " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
19994 " the cmap1 argument range that is specified with this routine, the\n"
19995 " smaller the subset of the cmap1 color palette that is used to\n"
19996 " represent the continuous data being plotted. If\n"
19997 " min_color is greater than\n"
19998 " max_color or\n"
19999 " max_color is greater than 1.0 or\n"
20000 " min_color is less than 0.0 then no change is made to the cmap1\n"
20001 " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
20002 "\n"
20003 " Redacted form: plscmap1_range(min_color, max_color)\n"
20004 "\n"
20005 " This function is currently used in example 33.\n"
20006 "\n"
20007 "\n"
20008 "\n"
20009 "SYNOPSIS:\n"
20010 "\n"
20011 "plscmap1_range(min_color, max_color)\n"
20012 "\n"
20013 "ARGUMENTS:\n"
20014 "\n"
20015 " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
20016 " than 0.0, then 0.0 is used instead.\n"
20017 "\n"
20018 " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
20019 " than 1.0, then 1.0 is used instead.\n"
20020 "\n"
20021 ""},
20022 { "plgcmap1_range", _wrap_plgcmap1_range, METH_NOARGS, "\n"
20023 "Get the cmap1 argument range for continuous color plots\n"
20024 "\n"
20025 "DESCRIPTION:\n"
20026 "\n"
20027 " Get the cmap1 argument range for continuous color plots. (Use\n"
20028 " plscmap1_range to set the cmap1 argument range.)\n"
20029 "\n"
20030 " Redacted form: plgcmap1_range(min_color, max_color)\n"
20031 "\n"
20032 " This function is currently not used in any example.\n"
20033 "\n"
20034 "\n"
20035 "\n"
20036 "SYNOPSIS:\n"
20037 "\n"
20038 "plgcmap1_range(min_color, max_color)\n"
20039 "\n"
20040 "ARGUMENTS:\n"
20041 "\n"
20042 " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20043 " minimum cmap1 argument.\n"
20044 "\n"
20045 " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20046 " maximum cmap1 argument.\n"
20047 "\n"
20048 ""},
20049 { "plscol0", _wrap_plscol0, METH_VARARGS, "\n"
20050 "Set 8-bit RGB values for given cmap0 color index\n"
20051 "\n"
20052 "DESCRIPTION:\n"
20053 "\n"
20054 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
20055 " index. Overwrites the previous color value for the given index and,\n"
20056 " thus, does not result in any additional allocation of space for\n"
20057 " colors.\n"
20058 "\n"
20059 " Redacted form: plscol0(icol0, r, g, b)\n"
20060 "\n"
20061 " This function is used in any example 31.\n"
20062 "\n"
20063 "\n"
20064 "\n"
20065 "SYNOPSIS:\n"
20066 "\n"
20067 "plscol0(icol0, r, g, b)\n"
20068 "\n"
20069 "ARGUMENTS:\n"
20070 "\n"
20071 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20072 " number of colors (which is set by default, by plscmap0n, or even\n"
20073 " by plscmap0).\n"
20074 "\n"
20075 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20076 " degree of red in the color.\n"
20077 "\n"
20078 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20079 " degree of green in the color.\n"
20080 "\n"
20081 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20082 " degree of blue in the color.\n"
20083 "\n"
20084 ""},
20085 { "plscol0a", _wrap_plscol0a, METH_VARARGS, "\n"
20086 "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
20087 "\n"
20088 "DESCRIPTION:\n"
20089 "\n"
20090 " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
20091 " (see the PLplot documentation) index. Overwrites the previous color\n"
20092 " value for the given index and, thus, does not result in any additional\n"
20093 " allocation of space for colors.\n"
20094 "\n"
20095 " This function is used in example 30.\n"
20096 "\n"
20097 "\n"
20098 "\n"
20099 "SYNOPSIS:\n"
20100 "\n"
20101 "plscol0a(icol0, r, g, b, alpha)\n"
20102 "\n"
20103 "ARGUMENTS:\n"
20104 "\n"
20105 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20106 " number of colors (which is set by default, by plscmap0n, or even\n"
20107 " by plscmap0).\n"
20108 "\n"
20109 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20110 " degree of red in the color.\n"
20111 "\n"
20112 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20113 " degree of green in the color.\n"
20114 "\n"
20115 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20116 " degree of blue in the color.\n"
20117 "\n"
20118 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20119 " (0.0-1.0).\n"
20120 "\n"
20121 ""},
20122 { "plscolbg", _wrap_plscolbg, METH_VARARGS, "\n"
20123 "Set the background color by 8-bit RGB value\n"
20124 "\n"
20125 "DESCRIPTION:\n"
20126 "\n"
20127 " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
20128 " the PLplot documentation).\n"
20129 "\n"
20130 " Redacted form: plscolbg(r, g, b)\n"
20131 "\n"
20132 " This function is used in examples 15 and 31.\n"
20133 "\n"
20134 "\n"
20135 "\n"
20136 "SYNOPSIS:\n"
20137 "\n"
20138 "plscolbg(r, g, b)\n"
20139 "\n"
20140 "ARGUMENTS:\n"
20141 "\n"
20142 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20143 " degree of red in the color.\n"
20144 "\n"
20145 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20146 " degree of green in the color.\n"
20147 "\n"
20148 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20149 " degree of blue in the color.\n"
20150 "\n"
20151 ""},
20152 { "plscolbga", _wrap_plscolbga, METH_VARARGS, "\n"
20153 "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
20154 "\n"
20155 "DESCRIPTION:\n"
20156 "\n"
20157 " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
20158 " PLFLT alpha transparency value (see the PLplot documentation).\n"
20159 "\n"
20160 " This function is used in example 31.\n"
20161 "\n"
20162 "\n"
20163 "\n"
20164 "SYNOPSIS:\n"
20165 "\n"
20166 "plscolbga(r, g, b, alpha)\n"
20167 "\n"
20168 "ARGUMENTS:\n"
20169 "\n"
20170 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20171 " degree of red in the color.\n"
20172 "\n"
20173 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20174 " degree of green in the color.\n"
20175 "\n"
20176 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20177 " degree of blue in the color.\n"
20178 "\n"
20179 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20180 " (0.0-1.0).\n"
20181 "\n"
20182 ""},
20183 { "plscolor", _wrap_plscolor, METH_O, "\n"
20184 "Used to globally turn color output on/off\n"
20185 "\n"
20186 "DESCRIPTION:\n"
20187 "\n"
20188 " Used to globally turn color output on/off for those drivers/devices\n"
20189 " that support it.\n"
20190 "\n"
20191 " Redacted form: plscolor(color)\n"
20192 "\n"
20193 " This function is used in example 31.\n"
20194 "\n"
20195 "\n"
20196 "\n"
20197 "SYNOPSIS:\n"
20198 "\n"
20199 "plscolor(color)\n"
20200 "\n"
20201 "ARGUMENTS:\n"
20202 "\n"
20203 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
20204 " turned off. If non-zero, color is turned on.\n"
20205 "\n"
20206 ""},
20207 { "plscompression", _wrap_plscompression, METH_O, "\n"
20208 "Set device-compression level\n"
20209 "\n"
20210 "DESCRIPTION:\n"
20211 "\n"
20212 " Set device-compression level. Only used for drivers that provide\n"
20213 " compression. This function, if used, should be invoked before a call\n"
20214 " to plinit.\n"
20215 "\n"
20216 " Redacted form: plscompression(compression)\n"
20217 "\n"
20218 " This function is used in example 31.\n"
20219 "\n"
20220 "\n"
20221 "\n"
20222 "SYNOPSIS:\n"
20223 "\n"
20224 "plscompression(compression)\n"
20225 "\n"
20226 "ARGUMENTS:\n"
20227 "\n"
20228 " compression (PLINT, input) : The desired compression level. This is\n"
20229 " a device-dependent value. Currently only the jpeg and png devices\n"
20230 " use these values. For jpeg value is the jpeg quality which should\n"
20231 " normally be in the range 0-95. Higher values denote higher quality\n"
20232 " and hence larger image sizes. For png values are in the range -1\n"
20233 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
20234 " A value of -1 denotes the default zlib compression level. Values\n"
20235 " in the range 10-99 are divided by 10 and then used as the zlib\n"
20236 " compression level. Higher compression levels correspond to greater\n"
20237 " compression and small file sizes at the expense of more\n"
20238 " computation.\n"
20239 "\n"
20240 ""},
20241 { "plsdev", _wrap_plsdev, METH_O, "\n"
20242 "Set the device (keyword) name\n"
20243 "\n"
20244 "DESCRIPTION:\n"
20245 "\n"
20246 " Set the device (keyword) name.\n"
20247 "\n"
20248 " Redacted form: plsdev(devname)\n"
20249 "\n"
20250 " This function is used in examples 1, 14, and 20.\n"
20251 "\n"
20252 "\n"
20253 "\n"
20254 "SYNOPSIS:\n"
20255 "\n"
20256 "plsdev(devname)\n"
20257 "\n"
20258 "ARGUMENTS:\n"
20259 "\n"
20260 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20261 " containing the device name keyword of the required output device.\n"
20262 " If\n"
20263 " devname is NULL or if the first character of the string is a ``?'',\n"
20264 " the normal (prompted) start up is used.\n"
20265 "\n"
20266 ""},
20267 { "plsdidev", _wrap_plsdidev, METH_VARARGS, "\n"
20268 "Set parameters that define current device-space window\n"
20269 "\n"
20270 "DESCRIPTION:\n"
20271 "\n"
20272 " Set relative margin width, aspect ratio, and relative justification\n"
20273 " that define current device-space window. If you want to just use the\n"
20274 " previous value for any of these, just pass in the magic value\n"
20275 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
20276 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
20277 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
20278 " to a device-specific value.\n"
20279 "\n"
20280 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20281 "\n"
20282 " This function is used in example 31.\n"
20283 "\n"
20284 "\n"
20285 "\n"
20286 "SYNOPSIS:\n"
20287 "\n"
20288 "plsdidev(mar, aspect, jx, jy)\n"
20289 "\n"
20290 "ARGUMENTS:\n"
20291 "\n"
20292 " mar (PLFLT, input) : Relative margin width.\n"
20293 "\n"
20294 " aspect (PLFLT, input) : Aspect ratio.\n"
20295 "\n"
20296 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20297 " the range -0.5 to 0.5.\n"
20298 "\n"
20299 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20300 " the range -0.5 to 0.5.\n"
20301 "\n"
20302 ""},
20303 { "plsdimap", _wrap_plsdimap, METH_VARARGS, "\n"
20304 "Set up transformation from metafile coordinates\n"
20305 "\n"
20306 "DESCRIPTION:\n"
20307 "\n"
20308 " Set up transformation from metafile coordinates. The size of the plot\n"
20309 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20310 " general-purpose facility just yet (not sure why the user would need\n"
20311 " it, for one).\n"
20312 "\n"
20313 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20314 " dimypmm)\n"
20315 "\n"
20316 " This function is not used in any examples.\n"
20317 "\n"
20318 "\n"
20319 "\n"
20320 "SYNOPSIS:\n"
20321 "\n"
20322 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20323 "\n"
20324 "ARGUMENTS:\n"
20325 "\n"
20326 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
20327 "\n"
20328 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
20329 "\n"
20330 " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
20331 "\n"
20332 " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
20333 "\n"
20334 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20335 "\n"
20336 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20337 "\n"
20338 ""},
20339 { "plsdiori", _wrap_plsdiori, METH_O, "\n"
20340 "Set plot orientation\n"
20341 "\n"
20342 "DESCRIPTION:\n"
20343 "\n"
20344 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20345 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20346 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20347 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20348 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20349 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20350 " not called the default value of rot is 0.\n"
20351 "\n"
20352 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20353 " probably want to change the aspect ratio to a value suitable for the\n"
20354 " plot orientation using a call to plsdidev or the command-line options\n"
20355 " -a or -freeaspect. For more documentation of those options see the\n"
20356 " PLplot documentation. Such command-line options can be set internally\n"
20357 " using plsetopt or set directly using the command line and parsed using\n"
20358 " a call to plparseopts.\n"
20359 "\n"
20360 " Redacted form: plsdiori(rot)\n"
20361 "\n"
20362 " This function is not used in any examples.\n"
20363 "\n"
20364 "\n"
20365 "\n"
20366 "SYNOPSIS:\n"
20367 "\n"
20368 "plsdiori(rot)\n"
20369 "\n"
20370 "ARGUMENTS:\n"
20371 "\n"
20372 " rot (PLFLT, input) : Plot orientation parameter.\n"
20373 "\n"
20374 ""},
20375 { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, "\n"
20376 "Set parameters that define current plot-space window\n"
20377 "\n"
20378 "DESCRIPTION:\n"
20379 "\n"
20380 " Set relative minima and maxima that define the current plot-space\n"
20381 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20382 " xmax, and ymax are 0., 0., 1., and 1.\n"
20383 "\n"
20384 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20385 "\n"
20386 " This function is used in example 31.\n"
20387 "\n"
20388 "\n"
20389 "\n"
20390 "SYNOPSIS:\n"
20391 "\n"
20392 "plsdiplt(xmin, ymin, xmax, ymax)\n"
20393 "\n"
20394 "ARGUMENTS:\n"
20395 "\n"
20396 " xmin (PLFLT, input) : Relative minimum in x.\n"
20397 "\n"
20398 " ymin (PLFLT, input) : Relative minimum in y.\n"
20399 "\n"
20400 " xmax (PLFLT, input) : Relative maximum in x.\n"
20401 "\n"
20402 " ymax (PLFLT, input) : Relative maximum in y.\n"
20403 "\n"
20404 ""},
20405 { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, "\n"
20406 "Set parameters incrementally (zoom mode) that define current plot-space window\n"
20407 "\n"
20408 "DESCRIPTION:\n"
20409 "\n"
20410 " Set relative minima and maxima incrementally (zoom mode) that define\n"
20411 " the current plot-space window. This function has the same effect as\n"
20412 " plsdiplt if that function has not been previously called. Otherwise,\n"
20413 " this function implements zoom mode using the transformation min_used =\n"
20414 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20415 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20416 " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20417 "\n"
20418 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20419 "\n"
20420 " This function is used in example 31.\n"
20421 "\n"
20422 "\n"
20423 "\n"
20424 "SYNOPSIS:\n"
20425 "\n"
20426 "plsdiplz(xmin, ymin, xmax, ymax)\n"
20427 "\n"
20428 "ARGUMENTS:\n"
20429 "\n"
20430 " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20431 "\n"
20432 " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20433 "\n"
20434 " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20435 "\n"
20436 " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20437 "\n"
20438 ""},
20439 { "plseed", _wrap_plseed, METH_O, "\n"
20440 "Set seed for internal random number generator.\n"
20441 "\n"
20442 "DESCRIPTION:\n"
20443 "\n"
20444 " Set the seed for the internal random number generator. See plrandd for\n"
20445 " further details.\n"
20446 "\n"
20447 " Redacted form: plseed(seed)\n"
20448 "\n"
20449 " This function is used in example 21.\n"
20450 "\n"
20451 "\n"
20452 "\n"
20453 "SYNOPSIS:\n"
20454 "\n"
20455 "plseed(seed)\n"
20456 "\n"
20457 "ARGUMENTS:\n"
20458 "\n"
20459 " seed (unsigned int, input) : Seed for random number generator.\n"
20460 "\n"
20461 ""},
20462 { "plsesc", _wrap_plsesc, METH_O, "\n"
20463 "Set the escape character for text strings\n"
20464 "\n"
20465 "DESCRIPTION:\n"
20466 "\n"
20467 " Set the escape character for text strings. From C (in contrast to\n"
20468 " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
20469 " characters are allowed to prevent the user from shooting himself in\n"
20470 " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
20471 " use of backslash as a character escape). Here are the allowed escape\n"
20472 " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
20473 " #, ASCII 35\n"
20474 " $, ASCII 36\n"
20475 " %, ASCII 37\n"
20476 " &, ASCII 38\n"
20477 " *, ASCII 42\n"
20478 " @, ASCII 64\n"
20479 " ^, ASCII 94\n"
20480 " ~, ASCII 126\n"
20481 "\n"
20482 "\n"
20483 " Redacted form: General: plsesc(esc)\n"
20484 "\n"
20485 "\n"
20486 " This function is used in example 29.\n"
20487 "\n"
20488 "\n"
20489 "\n"
20490 "SYNOPSIS:\n"
20491 "\n"
20492 "plsesc(esc)\n"
20493 "\n"
20494 "ARGUMENTS:\n"
20495 "\n"
20496 " esc (char, input) : Escape character.\n"
20497 "\n"
20498 ""},
20499 { "plsetopt", _wrap_plsetopt, METH_VARARGS, "\n"
20500 "Set any command-line option\n"
20501 "\n"
20502 "DESCRIPTION:\n"
20503 "\n"
20504 " Set any command-line option internally from a program before it\n"
20505 " invokes plinit. opt is the name of the command-line option and optarg\n"
20506 " is the corresponding command-line option argument.\n"
20507 "\n"
20508 " This function returns 0 on success.\n"
20509 "\n"
20510 " Redacted form: plsetopt(opt, optarg)\n"
20511 "\n"
20512 " This function is used in example 14.\n"
20513 "\n"
20514 "\n"
20515 "\n"
20516 "SYNOPSIS:\n"
20517 "\n"
20518 "PLINT plsetopt(opt, optarg)\n"
20519 "\n"
20520 "ARGUMENTS:\n"
20521 "\n"
20522 " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20523 " the command-line option.\n"
20524 "\n"
20525 " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20526 " containing the argument of the command-line option.\n"
20527 "\n"
20528 ""},
20529 { "plsfam", _wrap_plsfam, METH_VARARGS, "\n"
20530 "Set family file parameters\n"
20531 "\n"
20532 "DESCRIPTION:\n"
20533 "\n"
20534 " Sets variables dealing with output file familying. Does nothing if\n"
20535 " familying not supported by the driver. This routine, if used, must be\n"
20536 " called before initializing PLplot. See the PLplot documentation for\n"
20537 " more information.\n"
20538 "\n"
20539 " Redacted form: plsfam(fam, num, bmax)\n"
20540 "\n"
20541 " This function is used in examples 14 and 31.\n"
20542 "\n"
20543 "\n"
20544 "\n"
20545 "SYNOPSIS:\n"
20546 "\n"
20547 "plsfam(fam, num, bmax)\n"
20548 "\n"
20549 "ARGUMENTS:\n"
20550 "\n"
20551 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20552 " is enabled.\n"
20553 "\n"
20554 " num (PLINT, input) : Current family file number.\n"
20555 "\n"
20556 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20557 " file.\n"
20558 "\n"
20559 ""},
20560 { "plsfci", _wrap_plsfci, METH_O, "\n"
20561 "Set FCI (font characterization integer)\n"
20562 "\n"
20563 "DESCRIPTION:\n"
20564 "\n"
20565 " Sets font characteristics to be used at the start of the next string\n"
20566 " using the FCI approach. See the PLplot documentation for more\n"
20567 " information. Note, plsfont (which calls plsfci internally) provides a\n"
20568 " more user-friendly API for setting the font characterisitics.\n"
20569 "\n"
20570 " Redacted form: General: plsfci(fci)\n"
20571 "\n"
20572 "\n"
20573 " This function is used in example 23.\n"
20574 "\n"
20575 "\n"
20576 "\n"
20577 "SYNOPSIS:\n"
20578 "\n"
20579 "plsfci(fci)\n"
20580 "\n"
20581 "ARGUMENTS:\n"
20582 "\n"
20583 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20584 " of FCI.\n"
20585 "\n"
20586 ""},
20587 { "plsfnam", _wrap_plsfnam, METH_O, "\n"
20588 "Set output file name\n"
20589 "\n"
20590 "DESCRIPTION:\n"
20591 "\n"
20592 " Sets the current output file name, if applicable. If the file name\n"
20593 " has not been specified and is required by the driver, the user will be\n"
20594 " prompted for it. If using the X-windows output driver, this sets the\n"
20595 " display name. This routine, if used, must be called before\n"
20596 " initializing PLplot.\n"
20597 "\n"
20598 " Redacted form: plsfnam(fnam)\n"
20599 "\n"
20600 " This function is used in examples 1 and 20.\n"
20601 "\n"
20602 "\n"
20603 "\n"
20604 "SYNOPSIS:\n"
20605 "\n"
20606 "plsfnam(fnam)\n"
20607 "\n"
20608 "ARGUMENTS:\n"
20609 "\n"
20610 " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20611 " the file name.\n"
20612 "\n"
20613 ""},
20614 { "plsfont", _wrap_plsfont, METH_VARARGS, "\n"
20615 "Set family, style and weight of the current font\n"
20616 "\n"
20617 "DESCRIPTION:\n"
20618 "\n"
20619 " Sets the current font. See the PLplot documentation for more\n"
20620 " information on font selection.\n"
20621 "\n"
20622 " Redacted form: plsfont(family, style, weight)\n"
20623 "\n"
20624 " This function is used in example 23.\n"
20625 "\n"
20626 "\n"
20627 "\n"
20628 "SYNOPSIS:\n"
20629 "\n"
20630 "plsfont(family, style, weight)\n"
20631 "\n"
20632 "ARGUMENTS:\n"
20633 "\n"
20634 " family (PLINT, input) : Font family to select for the current font.\n"
20635 " The available values are given by the PL_FCI_* constants in\n"
20636 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20637 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20638 " signifies that the font family should not be altered.\n"
20639 "\n"
20640 " style (PLINT, input) : Font style to select for the current font.\n"
20641 " The available values are given by the PL_FCI_* constants in\n"
20642 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20643 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20644 " should not be altered.\n"
20645 "\n"
20646 " weight (PLINT, input) : Font weight to select for the current font.\n"
20647 " The available values are given by the PL_FCI_* constants in\n"
20648 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20649 " negative value signifies that the font weight should not be\n"
20650 " altered.\n"
20651 "\n"
20652 ""},
20653 { "plshades", _wrap_plshades, METH_VARARGS, "\n"
20654 "Shade regions on the basis of value\n"
20655 "\n"
20656 "DESCRIPTION:\n"
20657 "\n"
20658 " Shade regions on the basis of value. This is the high-level routine\n"
20659 " for making continuous color shaded plots with cmap1 while plshade\n"
20660 " should be used to plot individual shaded regions using either cmap0 or\n"
20661 " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20662 " our supported languages.\n"
20663 "\n"
20664 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20665 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20666 " pltr_data)\n"
20667 "\n"
20668 "\n"
20669 " This function is used in examples 16, 21, and 22.\n"
20670 "\n"
20671 "\n"
20672 "\n"
20673 "SYNOPSIS:\n"
20674 "\n"
20675 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20676 "\n"
20677 "ARGUMENTS:\n"
20678 "\n"
20679 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20680 " plot. Should have dimensions of\n"
20681 " nx by\n"
20682 " ny.\n"
20683 "\n"
20684 " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20685 "\n"
20686 " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20687 "\n"
20688 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20689 " the region that should be plotted in the shade plot. This\n"
20690 " function accepts x and y coordinates as input arguments and must\n"
20691 " return 1 if the point is to be included in the shade plot and 0\n"
20692 " otherwise. If you want to plot the entire shade plot (the usual\n"
20693 " case), this argument should be set to NULL.\n"
20694 "\n"
20695 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20696 " pltr below for how these arguments are used (only for the special case\n"
20697 " when the callback function\n"
20698 " pltr is not supplied).\n"
20699 "\n"
20700 " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20701 " corresponding to the edges of each shaded region that will be\n"
20702 " plotted by this function. To work properly the levels should be\n"
20703 " monotonic.\n"
20704 "\n"
20705 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20706 " of shade edge values in clevel).\n"
20707 "\n"
20708 " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20709 " pattern.\n"
20710 "\n"
20711 " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20712 " contours defining edges of shaded regions. The pen color is only\n"
20713 " temporary set for the contour drawing. Set this value to zero or\n"
20714 " less if no shade edge contours are wanted.\n"
20715 "\n"
20716 " cont_width (PLFLT, input) : Defines line width used for contours\n"
20717 " defining edges of shaded regions. This value may not be honored\n"
20718 " by all drivers. The pen width is only temporary set for the\n"
20719 " contour drawing. Set this value to zero or less if no shade edge\n"
20720 " contours are wanted.\n"
20721 "\n"
20722 " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20723 " region. Use plfill for this purpose.\n"
20724 "\n"
20725 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20726 " map to rectangles after coordinate transformation with pltrl.\n"
20727 " Otherwise, set rectangular to false. If rectangular is set to\n"
20728 " true, plshade tries to save time by filling large rectangles.\n"
20729 " This optimization fails if the coordinate transformation distorts\n"
20730 " the shape of rectangles. For example a plot in polar coordinates\n"
20731 " has to have rectangular set to false.\n"
20732 "\n"
20733 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20734 " defines the transformation between the zero-based indices of the\n"
20735 " matrix a and world coordinates. If\n"
20736 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20737 " indices of a are mapped to the range\n"
20738 " xmin through\n"
20739 " xmax and the y indices of a are mapped to the range\n"
20740 " ymin through\n"
20741 " ymax.For the C case, transformation functions are provided in the\n"
20742 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20743 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20744 " matrices. In addition, C callback routines for the transformation\n"
20745 " can be supplied by the user such as the mypltr function in\n"
20746 " examples/c/x09c.c which provides a general linear transformation\n"
20747 " between index coordinates and world coordinates.For languages\n"
20748 " other than C you should consult the PLplot documentation for the\n"
20749 " details concerning how PLTRANSFORM_callback arguments are\n"
20750 " interfaced. However, in general, a particular pattern of\n"
20751 " callback-associated arguments such as a tr vector with 6 elements;\n"
20752 " xg and yg vectors; or xg and yg matrices are respectively\n"
20753 " interfaced to a linear-transformation routine similar to the above\n"
20754 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20755 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20756 " support native language callbacks for handling index to\n"
20757 " world-coordinate transformations. Examples of these various\n"
20758 " approaches are given in examples/<language>x09*,\n"
20759 " examples/<language>x16*, examples/<language>x20*,\n"
20760 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20761 " supported languages.\n"
20762 "\n"
20763 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20764 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20765 " externally supplied.\n"
20766 "\n"
20767 ""},
20768 { "plshade", _wrap_plshade, METH_VARARGS, "\n"
20769 "Shade individual region on the basis of value\n"
20770 "\n"
20771 "DESCRIPTION:\n"
20772 "\n"
20773 " Shade individual region on the basis of value. Use plshades if you\n"
20774 " want to shade a number of contiguous regions using continuous colors.\n"
20775 " In particular the edge contours are treated properly in plshades. If\n"
20776 " you attempt to do contiguous regions with plshade the contours at the\n"
20777 " edge of the shade are partially obliterated by subsequent plots of\n"
20778 " contiguous shaded regions.\n"
20779 "\n"
20780 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20781 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20782 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20783 "\n"
20784 "\n"
20785 " This function is used in example 15.\n"
20786 "\n"
20787 "\n"
20788 "\n"
20789 "SYNOPSIS:\n"
20790 "\n"
20791 "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"
20792 "\n"
20793 "ARGUMENTS:\n"
20794 "\n"
20795 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20796 " plot. Should have dimensions of\n"
20797 " nx by\n"
20798 " ny.\n"
20799 "\n"
20800 " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20801 "\n"
20802 " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20803 "\n"
20804 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20805 " the region that should be plotted in the shade plot. This\n"
20806 " function accepts x and y coordinates as input arguments and must\n"
20807 " return 1 if the point is to be included in the shade plot and 0\n"
20808 " otherwise. If you want to plot the entire shade plot (the usual\n"
20809 " case), this argument should be set to NULL.\n"
20810 "\n"
20811 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20812 " pltr below for how these arguments are used (only for the special case\n"
20813 " when the callback function\n"
20814 " pltr is not supplied).\n"
20815 "\n"
20816 " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20817 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20818 "\n"
20819 " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20820 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20821 "\n"
20822 " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20823 " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20824 " then sh_color is interpreted as a cmap1 argument in the range\n"
20825 " (0.0-1.0).\n"
20826 "\n"
20827 " sh_color (PLFLT, input) : Defines color map index with integer\n"
20828 " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20829 "\n"
20830 " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20831 "\n"
20832 " min_color (PLINT, input) : Defines pen color, width used by the\n"
20833 " boundary of shaded region. The min values are used for the\n"
20834 " shade_min boundary, and the max values are used on the shade_max\n"
20835 " boundary. Set color and width to zero for no plotted boundaries.\n"
20836 "\n"
20837 " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20838 " boundary of shaded region. The min values are used for the\n"
20839 " shade_min boundary, and the max values are used on the shade_max\n"
20840 " boundary. Set color and width to zero for no plotted boundaries.\n"
20841 "\n"
20842 " max_color (PLINT, input) : Defines pen color, width used by the\n"
20843 " boundary of shaded region. The min values are used for the\n"
20844 " shade_min boundary, and the max values are used on the shade_max\n"
20845 " boundary. Set color and width to zero for no plotted boundaries.\n"
20846 "\n"
20847 " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20848 " boundary of shaded region. The min values are used for the\n"
20849 " shade_min boundary, and the max values are used on the shade_max\n"
20850 " boundary. Set color and width to zero for no plotted boundaries.\n"
20851 "\n"
20852 " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20853 " Use plfill. Future version of PLplot may have other fill\n"
20854 " routines.\n"
20855 "\n"
20856 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20857 " map to rectangles after coordinate transformation with pltrl.\n"
20858 " Otherwise, set rectangular to false. If rectangular is set to\n"
20859 " true, plshade tries to save time by filling large rectangles.\n"
20860 " This optimization fails if the coordinate transformation distorts\n"
20861 " the shape of rectangles. For example a plot in polar coordinates\n"
20862 " has to have rectangular set to false.\n"
20863 "\n"
20864 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20865 " defines the transformation between the zero-based indices of the\n"
20866 " matrix a and world coordinates. If\n"
20867 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20868 " indices of a are mapped to the range\n"
20869 " xmin through\n"
20870 " xmax and the y indices of a are mapped to the range\n"
20871 " ymin through\n"
20872 " ymax.For the C case, transformation functions are provided in the\n"
20873 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20874 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20875 " matrices. In addition, C callback routines for the transformation\n"
20876 " can be supplied by the user such as the mypltr function in\n"
20877 " examples/c/x09c.c which provides a general linear transformation\n"
20878 " between index coordinates and world coordinates.For languages\n"
20879 " other than C you should consult the PLplot documentation for the\n"
20880 " details concerning how PLTRANSFORM_callback arguments are\n"
20881 " interfaced. However, in general, a particular pattern of\n"
20882 " callback-associated arguments such as a tr vector with 6 elements;\n"
20883 " xg and yg vectors; or xg and yg matrices are respectively\n"
20884 " interfaced to a linear-transformation routine similar to the above\n"
20885 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20886 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20887 " support native language callbacks for handling index to\n"
20888 " world-coordinate transformations. Examples of these various\n"
20889 " approaches are given in examples/<language>x09*,\n"
20890 " examples/<language>x16*, examples/<language>x20*,\n"
20891 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20892 " supported languages.\n"
20893 "\n"
20894 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20895 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20896 " externally supplied.\n"
20897 "\n"
20898 ""},
20899 { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, "\n"
20900 "Assign a function to use for generating custom axis labels\n"
20901 "\n"
20902 "DESCRIPTION:\n"
20903 "\n"
20904 " This function allows a user to provide their own function to provide\n"
20905 " axis label text. The user function is given the numeric value for a\n"
20906 " point on an axis and returns a string label to correspond with that\n"
20907 " value. Custom axis labels can be enabled by passing appropriate\n"
20908 " arguments to plenv, plbox, plbox3 and similar functions.\n"
20909 "\n"
20910 " This function is used in example 19.\n"
20911 "\n"
20912 "\n"
20913 "\n"
20914 "SYNOPSIS:\n"
20915 "\n"
20916 "plslabelfunc(label_func, label_data)\n"
20917 "\n"
20918 "ARGUMENTS:\n"
20919 "\n"
20920 " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20921 " label function. In order to reset to the default labelling, set\n"
20922 " this to NULL. The labelling function parameters are, in order:\n"
20923 " axis: This indicates which axis a label is being requested for.\n"
20924 " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20925 "\n"
20926 " value: This is the value along the axis which is being labelled.\n"
20927 "\n"
20928 " label_text: The string representation of the label value.\n"
20929 "\n"
20930 " length: The maximum length in characters allowed for label_text.\n"
20931 "\n"
20932 "\n"
20933 " label_data (PLPointer, input) : This parameter may be used to pass\n"
20934 " data to the label_func function.\n"
20935 "\n"
20936 ""},
20937 { "plsmaj", _wrap_plsmaj, METH_VARARGS, "\n"
20938 "Set length of major ticks\n"
20939 "\n"
20940 "DESCRIPTION:\n"
20941 "\n"
20942 " This sets up the length of the major ticks. The actual length is the\n"
20943 " product of the default length and a scaling factor as for character\n"
20944 " height.\n"
20945 "\n"
20946 " Redacted form: plsmaj(def, scale)\n"
20947 "\n"
20948 " This function is used in example 29.\n"
20949 "\n"
20950 "\n"
20951 "\n"
20952 "SYNOPSIS:\n"
20953 "\n"
20954 "plsmaj(def, scale)\n"
20955 "\n"
20956 "ARGUMENTS:\n"
20957 "\n"
20958 " def (PLFLT, input) : The default length of a major tick in\n"
20959 " millimeters, should be set to zero if the default length is to\n"
20960 " remain unchanged.\n"
20961 "\n"
20962 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20963 " actual tick length.\n"
20964 "\n"
20965 ""},
20966 { "plsmem", _wrap_plsmem, METH_VARARGS, "\n"
20967 "Set the memory area to be plotted (RGB)\n"
20968 "\n"
20969 "DESCRIPTION:\n"
20970 "\n"
20971 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20972 " the dev member of the stream structure. Also set the number of pixels\n"
20973 " in the memory passed in\n"
20974 " plotmem, which is a block of memory\n"
20975 " maxy by\n"
20976 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
20977 "\n"
20978 " This memory will have to be freed by the user!\n"
20979 "\n"
20980 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20981 "\n"
20982 " This function is not used in any examples.\n"
20983 "\n"
20984 "\n"
20985 "\n"
20986 "SYNOPSIS:\n"
20987 "\n"
20988 "plsmem(maxx, maxy, plotmem)\n"
20989 "\n"
20990 "ARGUMENTS:\n"
20991 "\n"
20992 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20993 "\n"
20994 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20995 "\n"
20996 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
20997 " user-supplied writeable memory area.\n"
20998 "\n"
20999 ""},
21000 { "plsmema", _wrap_plsmema, METH_VARARGS, "\n"
21001 "Set the memory area to be plotted (RGBA)\n"
21002 "\n"
21003 "DESCRIPTION:\n"
21004 "\n"
21005 " Set the memory area to be plotted (with the memcairo driver) as the\n"
21006 " dev member of the stream structure. Also set the number of pixels in\n"
21007 " the memory passed in\n"
21008 " plotmem, which is a block of memory\n"
21009 " maxy by\n"
21010 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
21011 "\n"
21012 " This memory will have to be freed by the user!\n"
21013 "\n"
21014 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
21015 "\n"
21016 " This function is not used in any examples.\n"
21017 "\n"
21018 "\n"
21019 "\n"
21020 "SYNOPSIS:\n"
21021 "\n"
21022 "plsmema(maxx, maxy, plotmem)\n"
21023 "\n"
21024 "ARGUMENTS:\n"
21025 "\n"
21026 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21027 "\n"
21028 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21029 "\n"
21030 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21031 " user-supplied writeable memory area.\n"
21032 "\n"
21033 ""},
21034 { "plsmin", _wrap_plsmin, METH_VARARGS, "\n"
21035 "Set length of minor ticks\n"
21036 "\n"
21037 "DESCRIPTION:\n"
21038 "\n"
21039 " This sets up the length of the minor ticks and the length of the\n"
21040 " terminals on error bars. The actual length is the product of the\n"
21041 " default length and a scaling factor as for character height.\n"
21042 "\n"
21043 " Redacted form: plsmin(def, scale)\n"
21044 "\n"
21045 " This function is used in example 29.\n"
21046 "\n"
21047 "\n"
21048 "\n"
21049 "SYNOPSIS:\n"
21050 "\n"
21051 "plsmin(def, scale)\n"
21052 "\n"
21053 "ARGUMENTS:\n"
21054 "\n"
21055 " def (PLFLT, input) : The default length of a minor tick in\n"
21056 " millimeters, should be set to zero if the default length is to\n"
21057 " remain unchanged.\n"
21058 "\n"
21059 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21060 " actual tick length.\n"
21061 "\n"
21062 ""},
21063 { "plsori", _wrap_plsori, METH_O, "\n"
21064 "Set orientation\n"
21065 "\n"
21066 "DESCRIPTION:\n"
21067 "\n"
21068 " Set integer plot orientation parameter. This function is identical to\n"
21069 " plsdiori except for the type of the argument, and should be used in\n"
21070 " the same way. See the documentation of plsdiori for details.\n"
21071 "\n"
21072 " Redacted form: plsori(ori)\n"
21073 "\n"
21074 " This function is used in example 3.\n"
21075 "\n"
21076 "\n"
21077 "\n"
21078 "SYNOPSIS:\n"
21079 "\n"
21080 "plsori(ori)\n"
21081 "\n"
21082 "ARGUMENTS:\n"
21083 "\n"
21084 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
21085 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
21086 " angle.\n"
21087 "\n"
21088 ""},
21089 { "plspage", _wrap_plspage, METH_VARARGS, "\n"
21090 "Set page parameters\n"
21091 "\n"
21092 "DESCRIPTION:\n"
21093 "\n"
21094 " Sets the page configuration (optional). If an individual parameter is\n"
21095 " zero then that parameter value is not updated. Not all parameters are\n"
21096 " recognized by all drivers and the interpretation is device-dependent.\n"
21097 " The X-window driver uses the length and offset parameters to determine\n"
21098 " the window size and location. The length and offset values are\n"
21099 " expressed in units that are specific to the current driver. For\n"
21100 " instance: screen drivers will usually interpret them as number of\n"
21101 " pixels, whereas printer drivers will usually use mm.\n"
21102 "\n"
21103 " This routine, if used, must be called before initializing PLplot. It\n"
21104 " may be called at later times for interactive drivers to change only\n"
21105 " the dpi for subsequent redraws which you can force via a call to\n"
21106 " plreplot. If this function is not called then the page size defaults\n"
21107 " to landscape A4 for drivers which use real world page sizes and 744\n"
21108 " pixels wide by 538 pixels high for raster drivers. The default value\n"
21109 " for dx and dy is 90 pixels per inch for raster drivers.\n"
21110 "\n"
21111 "\n"
21112 "\n"
21113 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21114 "\n"
21115 " This function is used in examples 14 and 31.\n"
21116 "\n"
21117 "\n"
21118 "\n"
21119 "SYNOPSIS:\n"
21120 "\n"
21121 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21122 "\n"
21123 "ARGUMENTS:\n"
21124 "\n"
21125 " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
21126 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21127 " (e.g. mm).\n"
21128 "\n"
21129 " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
21130 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21131 " (e.g. mm).\n"
21132 "\n"
21133 " xleng (PLINT, input) : Page length, x.\n"
21134 "\n"
21135 " yleng (PLINT, input) : Page length, y.\n"
21136 "\n"
21137 " xoff (PLINT, input) : Page offset, x.\n"
21138 "\n"
21139 " yoff (PLINT, input) : Page offset, y.\n"
21140 "\n"
21141 ""},
21142 { "plspal0", _wrap_plspal0, METH_O, "\n"
21143 "Set the cmap0 palette using the specified cmap0*.pal format file\n"
21144 "\n"
21145 "DESCRIPTION:\n"
21146 "\n"
21147 " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
21148 "\n"
21149 " Redacted form: plspal0(filename)\n"
21150 "\n"
21151 " This function is in example 16.\n"
21152 "\n"
21153 "\n"
21154 "\n"
21155 "SYNOPSIS:\n"
21156 "\n"
21157 "plspal0(filename)\n"
21158 "\n"
21159 "ARGUMENTS:\n"
21160 "\n"
21161 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21162 " containing the name of the cmap0*.pal file. If this string is\n"
21163 " empty, use the default cmap0*.pal file.\n"
21164 "\n"
21165 ""},
21166 { "plspal1", _wrap_plspal1, METH_VARARGS, "\n"
21167 "Set the cmap1 palette using the specified cmap1*.pal format file\n"
21168 "\n"
21169 "DESCRIPTION:\n"
21170 "\n"
21171 " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
21172 "\n"
21173 " Redacted form: plspal1(filename, interpolate)\n"
21174 "\n"
21175 " This function is used in example 16.\n"
21176 "\n"
21177 "\n"
21178 "\n"
21179 "SYNOPSIS:\n"
21180 "\n"
21181 "plspal1(filename, interpolate)\n"
21182 "\n"
21183 "ARGUMENTS:\n"
21184 "\n"
21185 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21186 " containing the name of the cmap1*.pal file. If this string is\n"
21187 " empty, use the default cmap1*.pal file.\n"
21188 "\n"
21189 " interpolate (PLBOOL, input) : If this parameter is true, the\n"
21190 " columns containing the intensity index, r, g, b, alpha and\n"
21191 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
21192 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
21193 " a flag which controls whether the r, g, b data sent to plscmap1la\n"
21194 " are interpreted as HLS or RGB.) If this parameter is false, the\n"
21195 " intensity index and alt_hue_path columns are ignored and the r, g,\n"
21196 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
21197 " are used instead to set the cmap1 palette directly with a call to\n"
21198 " plscmap1a.\n"
21199 "\n"
21200 ""},
21201 { "plspause", _wrap_plspause, METH_O, "\n"
21202 "Set the pause (on end-of-page) status\n"
21203 "\n"
21204 "DESCRIPTION:\n"
21205 "\n"
21206 " Set the pause (on end-of-page) status.\n"
21207 "\n"
21208 " Redacted form: plspause(pause)\n"
21209 "\n"
21210 " This function is in examples 14,20.\n"
21211 "\n"
21212 "\n"
21213 "\n"
21214 "SYNOPSIS:\n"
21215 "\n"
21216 "plspause(pause)\n"
21217 "\n"
21218 "ARGUMENTS:\n"
21219 "\n"
21220 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
21221 " end-of-page for those drivers which support this. Otherwise there\n"
21222 " is no pause.\n"
21223 "\n"
21224 ""},
21225 { "plsstrm", _wrap_plsstrm, METH_O, "\n"
21226 "Set current output stream\n"
21227 "\n"
21228 "DESCRIPTION:\n"
21229 "\n"
21230 " Sets the number of the current output stream. The stream number\n"
21231 " defaults to 0 unless changed by this routine. The first use of this\n"
21232 " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
21233 "\n"
21234 " Redacted form: plsstrm(strm)\n"
21235 "\n"
21236 " This function is examples 1,14,20.\n"
21237 "\n"
21238 "\n"
21239 "\n"
21240 "SYNOPSIS:\n"
21241 "\n"
21242 "plsstrm(strm)\n"
21243 "\n"
21244 "ARGUMENTS:\n"
21245 "\n"
21246 " strm (PLINT, input) : The current stream number.\n"
21247 "\n"
21248 ""},
21249 { "plssub", _wrap_plssub, METH_VARARGS, "\n"
21250 "Set the number of subpages in x and y\n"
21251 "\n"
21252 "DESCRIPTION:\n"
21253 "\n"
21254 " Set the number of subpages in x and y.\n"
21255 "\n"
21256 " Redacted form: plssub(nx, ny)\n"
21257 "\n"
21258 " This function is examples 1,2,14,21,25,27.\n"
21259 "\n"
21260 "\n"
21261 "\n"
21262 "SYNOPSIS:\n"
21263 "\n"
21264 "plssub(nx, ny)\n"
21265 "\n"
21266 "ARGUMENTS:\n"
21267 "\n"
21268 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
21269 " of window columns).\n"
21270 "\n"
21271 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
21272 " of window rows).\n"
21273 "\n"
21274 ""},
21275 { "plssym", _wrap_plssym, METH_VARARGS, "\n"
21276 "Set symbol size\n"
21277 "\n"
21278 "DESCRIPTION:\n"
21279 "\n"
21280 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
21281 " plsym. The actual height of a symbol is the product of the default\n"
21282 " symbol size and a scaling factor as for the character height.\n"
21283 "\n"
21284 " Redacted form: plssym(def, scale)\n"
21285 "\n"
21286 " This function is used in example 29.\n"
21287 "\n"
21288 "\n"
21289 "\n"
21290 "SYNOPSIS:\n"
21291 "\n"
21292 "plssym(def, scale)\n"
21293 "\n"
21294 "ARGUMENTS:\n"
21295 "\n"
21296 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
21297 " should be set to zero if the default height is to remain\n"
21298 " unchanged.\n"
21299 "\n"
21300 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21301 " actual symbol height.\n"
21302 "\n"
21303 ""},
21304 { "plstar", _wrap_plstar, METH_VARARGS, "\n"
21305 "Initialization\n"
21306 "\n"
21307 "DESCRIPTION:\n"
21308 "\n"
21309 " Initializing the plotting package. The program prompts for the device\n"
21310 " keyword or number of the desired output device. Hitting a RETURN in\n"
21311 " response to the prompt is the same as selecting the first device. If\n"
21312 " only one device is enabled when PLplot is installed, plstar will issue\n"
21313 " no prompt. The output device is divided into nx by ny subpages, each\n"
21314 " of which may be used independently. The subroutine pladv is used to\n"
21315 " advance from one subpage to the next.\n"
21316 "\n"
21317 " Redacted form: plstar(nx, ny)\n"
21318 "\n"
21319 " This function is used in example 1.\n"
21320 "\n"
21321 "\n"
21322 "\n"
21323 "SYNOPSIS:\n"
21324 "\n"
21325 "plstar(nx, ny)\n"
21326 "\n"
21327 "ARGUMENTS:\n"
21328 "\n"
21329 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21330 " x direction.\n"
21331 "\n"
21332 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21333 " y direction.\n"
21334 "\n"
21335 ""},
21336 { "plstart", _wrap_plstart, METH_VARARGS, "\n"
21337 "Initialization\n"
21338 "\n"
21339 "DESCRIPTION:\n"
21340 "\n"
21341 " Alternative to plstar for initializing the plotting package. The\n"
21342 " device name keyword for the desired output device must be supplied as\n"
21343 " an argument. These keywords are the same as those printed out by\n"
21344 " plstar. If the requested device is not available, or if the input\n"
21345 " string is empty or begins with ``?'', the prompted start up of plstar\n"
21346 " is used. This routine also divides the output device page into nx by\n"
21347 " ny subpages, each of which may be used independently. The subroutine\n"
21348 " pladv is used to advance from one subpage to the next.\n"
21349 "\n"
21350 " Redacted form: General: plstart(devname, nx, ny)\n"
21351 "\n"
21352 "\n"
21353 " This function is not used in any examples.\n"
21354 "\n"
21355 "\n"
21356 "\n"
21357 "SYNOPSIS:\n"
21358 "\n"
21359 "plstart(devname, nx, ny)\n"
21360 "\n"
21361 "ARGUMENTS:\n"
21362 "\n"
21363 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
21364 " containing the device name keyword of the required output device.\n"
21365 " If\n"
21366 " devname is NULL or if the first character of the string is a ``?'',\n"
21367 " the normal (prompted) start up is used.\n"
21368 "\n"
21369 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21370 " x direction.\n"
21371 "\n"
21372 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21373 " y direction.\n"
21374 "\n"
21375 ""},
21376 { "plstransform", _wrap_plstransform, METH_VARARGS, "\n"
21377 "Set a global coordinate transform function\n"
21378 "\n"
21379 "DESCRIPTION:\n"
21380 "\n"
21381 " This function can be used to define a coordinate transformation which\n"
21382 " affects all elements drawn within the current plot window. The\n"
21383 " coordinate_transform callback function is similar to that provided for\n"
21384 " the plmap and plmeridians functions. The coordinate_transform_data\n"
21385 " parameter may be used to pass extra data to coordinate_transform.\n"
21386 "\n"
21387 " Redacted form: General: plstransform(coordinate_transform,\n"
21388 " coordinate_transform_data)\n"
21389 "\n"
21390 "\n"
21391 " This function is used in examples 19 and 22.\n"
21392 "\n"
21393 "\n"
21394 "\n"
21395 "SYNOPSIS:\n"
21396 "\n"
21397 "plstransform(coordinate_transform, coordinate_transform_data)\n"
21398 "\n"
21399 "ARGUMENTS:\n"
21400 "\n"
21401 " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
21402 " function that defines the transformation from the input (x, y)\n"
21403 " world coordinates to new PLplot world coordinates. If\n"
21404 " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
21405 " case), then no transform is applied.\n"
21406 "\n"
21407 " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
21408 " for\n"
21409 " coordinate_transform.\n"
21410 "\n"
21411 ""},
21412 { "plstring", _wrap_plstring, METH_VARARGS, "\n"
21413 "Plot a glyph at the specified points\n"
21414 "\n"
21415 "DESCRIPTION:\n"
21416 "\n"
21417 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21418 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21419 " is specified with a PLplot user string. Note that the user string is\n"
21420 " not actually limited to one glyph so it is possible (but not normally\n"
21421 " useful) to plot more than one glyph at the specified points with this\n"
21422 " function. As with plmtex and plptex, the user string can contain FCI\n"
21423 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21424 " else PLplot escapes for Hershey or unicode text to determine the\n"
21425 " glyph.\n"
21426 "\n"
21427 " Redacted form: plstring(x, y, string)\n"
21428 "\n"
21429 " This function is used in examples 4, 21 and 26.\n"
21430 "\n"
21431 "\n"
21432 "\n"
21433 "SYNOPSIS:\n"
21434 "\n"
21435 "plstring(n, x, y, string)\n"
21436 "\n"
21437 "ARGUMENTS:\n"
21438 "\n"
21439 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21440 "\n"
21441 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21442 " the points.\n"
21443 "\n"
21444 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21445 " the points.\n"
21446 "\n"
21447 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21448 " the glyph(s) to be plotted at each of the n points.\n"
21449 "\n"
21450 ""},
21451 { "plstring3", _wrap_plstring3, METH_VARARGS, "\n"
21452 "Plot a glyph at the specified 3D points\n"
21453 "\n"
21454 "DESCRIPTION:\n"
21455 "\n"
21456 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21457 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21458 " this function similar to what is done for plline3. The glyph is\n"
21459 " specified with a PLplot user string. Note that the user string is not\n"
21460 " actually limited to one glyph so it is possible (but not normally\n"
21461 " useful) to plot more than one glyph at the specified points with this\n"
21462 " function. As with plmtex and plptex, the user string can contain FCI\n"
21463 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21464 " else PLplot escapes for Hershey or unicode text to determine the\n"
21465 " glyph.\n"
21466 "\n"
21467 " Redacted form: plstring3(x, y, z, string)\n"
21468 "\n"
21469 " This function is used in example 18.\n"
21470 "\n"
21471 "\n"
21472 "\n"
21473 "SYNOPSIS:\n"
21474 "\n"
21475 "plstring3(n, x, y, z, string)\n"
21476 "\n"
21477 "ARGUMENTS:\n"
21478 "\n"
21479 " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21480 "\n"
21481 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21482 " the points.\n"
21483 "\n"
21484 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21485 " the points.\n"
21486 "\n"
21487 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21488 " the points.\n"
21489 "\n"
21490 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21491 " the glyph(s) to be plotted at each of the n points. points.\n"
21492 "\n"
21493 ""},
21494 { "plstripa", _wrap_plstripa, METH_VARARGS, "\n"
21495 "Add a point to a strip chart\n"
21496 "\n"
21497 "DESCRIPTION:\n"
21498 "\n"
21499 " Add a point to a given pen of a given strip chart. There is no need\n"
21500 " for all pens to have the same number of points or to be equally\n"
21501 " sampled in the x coordinate. Allocates memory and rescales as\n"
21502 " necessary.\n"
21503 "\n"
21504 " Redacted form: plstripa(id, pen, x, y)\n"
21505 "\n"
21506 " This function is used in example 17.\n"
21507 "\n"
21508 "\n"
21509 "\n"
21510 "SYNOPSIS:\n"
21511 "\n"
21512 "plstripa(id, pen, x, y)\n"
21513 "\n"
21514 "ARGUMENTS:\n"
21515 "\n"
21516 " id (PLINT, input) : Identification number of the strip chart (set\n"
21517 " up in plstripc).\n"
21518 "\n"
21519 " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21520 "\n"
21521 " x (PLFLT, input) : X coordinate of point to plot.\n"
21522 "\n"
21523 " y (PLFLT, input) : Y coordinate of point to plot.\n"
21524 "\n"
21525 ""},
21526 { "plstripc", _wrap_plstripc, METH_VARARGS, "\n"
21527 "Create a 4-pen strip chart\n"
21528 "\n"
21529 "DESCRIPTION:\n"
21530 "\n"
21531 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21532 "\n"
21533 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21534 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21535 " styline, legline, labx, laby, labz)\n"
21536 "\n"
21537 "\n"
21538 " This function is used in example 17.\n"
21539 "\n"
21540 "\n"
21541 "\n"
21542 "SYNOPSIS:\n"
21543 "\n"
21544 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21545 "\n"
21546 "ARGUMENTS:\n"
21547 "\n"
21548 " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21549 " number of the strip chart to use on plstripa and plstripd.\n"
21550 "\n"
21551 " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21552 " the x-axis specification as in plbox.\n"
21553 "\n"
21554 " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21555 " the y-axis specification as in plbox.\n"
21556 "\n"
21557 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21558 " change as data are added.\n"
21559 "\n"
21560 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21561 " change as data are added.\n"
21562 "\n"
21563 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21564 " is multiplied by the factor (1 +\n"
21565 " xjump) .\n"
21566 "\n"
21567 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21568 " change as data are added.\n"
21569 "\n"
21570 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21571 " change as data are added.\n"
21572 "\n"
21573 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21574 "\n"
21575 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21576 "\n"
21577 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21578 " true, otherwise not.\n"
21579 "\n"
21580 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21581 " otherwise slide display.\n"
21582 "\n"
21583 " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21584 "\n"
21585 " collab (PLINT, input) : Legend color index (cmap0).\n"
21586 "\n"
21587 " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21588 " indices for the 4 pens.\n"
21589 "\n"
21590 " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21591 " indices for the 4 pens.\n"
21592 "\n"
21593 " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21594 " strings containing legends for the 4 pens.\n"
21595 "\n"
21596 " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21597 " the label for the x axis.\n"
21598 "\n"
21599 " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21600 " the label for the y axis.\n"
21601 "\n"
21602 " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21603 " the plot title.\n"
21604 "\n"
21605 ""},
21606 { "plstripd", _wrap_plstripd, METH_O, "\n"
21607 "Deletes and releases memory used by a strip chart\n"
21608 "\n"
21609 "DESCRIPTION:\n"
21610 "\n"
21611 " Deletes and releases memory used by a strip chart.\n"
21612 "\n"
21613 " Redacted form: plstripd(id)\n"
21614 "\n"
21615 " This function is used in example 17.\n"
21616 "\n"
21617 "\n"
21618 "\n"
21619 "SYNOPSIS:\n"
21620 "\n"
21621 "plstripd(id)\n"
21622 "\n"
21623 "ARGUMENTS:\n"
21624 "\n"
21625 " id (PLINT, input) : Identification number of strip chart to delete.\n"
21626 "\n"
21627 ""},
21628 { "plstyl", _wrap_plstyl, METH_VARARGS, "\n"
21629 "Set line style\n"
21630 "\n"
21631 "DESCRIPTION:\n"
21632 "\n"
21633 " This sets up the line style for all lines subsequently drawn. A line\n"
21634 " consists of segments in which the pen is alternately down and up. The\n"
21635 " lengths of these segments are passed in the vectors mark and space\n"
21636 " respectively. The number of mark-space pairs is specified by nms. In\n"
21637 " order to return the line style to the default continuous line, plstyl\n"
21638 " should be called with nms =0 .(see also pllsty)\n"
21639 "\n"
21640 " Redacted form: plstyl(mark, space)\n"
21641 "\n"
21642 " This function is used in examples 1, 9, and 14.\n"
21643 "\n"
21644 "\n"
21645 "\n"
21646 "SYNOPSIS:\n"
21647 "\n"
21648 "plstyl(nms, mark, space)\n"
21649 "\n"
21650 "ARGUMENTS:\n"
21651 "\n"
21652 " nms (PLINT, input) : The number of mark and space elements in a\n"
21653 " line. Thus a simple broken line can be obtained by setting nms=1\n"
21654 " . A continuous line is specified by setting nms=0 .\n"
21655 "\n"
21656 " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21657 " segments during which the pen is down, measured in micrometers.\n"
21658 "\n"
21659 " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21660 " the segments during which the pen is up, measured in micrometers.\n"
21661 "\n"
21662 ""},
21663 { "plsvect", _wrap_plsvect, METH_VARARGS, "\n"
21664 "Set arrow style for vector plots\n"
21665 "\n"
21666 "DESCRIPTION:\n"
21667 "\n"
21668 " Set the style for the arrow used by plvect to plot vectors.\n"
21669 "\n"
21670 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21671 "\n"
21672 " This function is used in example 22.\n"
21673 "\n"
21674 "\n"
21675 "\n"
21676 "SYNOPSIS:\n"
21677 "\n"
21678 "plsvect(arrowx, arrowy, npts, fill)\n"
21679 "\n"
21680 "ARGUMENTS:\n"
21681 "\n"
21682 " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21683 " the x and y points which make up the arrow. The arrow is plotted\n"
21684 " by joining these points to form a polygon. The scaling assumes\n"
21685 " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21686 " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21687 " will be reset to its default.\n"
21688 "\n"
21689 " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21690 " arrowy.\n"
21691 "\n"
21692 " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21693 " fill is false then the arrow is open.\n"
21694 "\n"
21695 ""},
21696 { "plsvpa", _wrap_plsvpa, METH_VARARGS, "\n"
21697 "Specify viewport in absolute coordinates\n"
21698 "\n"
21699 "DESCRIPTION:\n"
21700 "\n"
21701 " Alternate routine to plvpor for setting up the viewport. This routine\n"
21702 " should be used only if the viewport is required to have a definite\n"
21703 " size in millimeters. The routine plgspa is useful for finding out the\n"
21704 " size of the current subpage.\n"
21705 "\n"
21706 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21707 "\n"
21708 " This function is used in example 10.\n"
21709 "\n"
21710 "\n"
21711 "\n"
21712 "SYNOPSIS:\n"
21713 "\n"
21714 "plsvpa(xmin, xmax, ymin, ymax)\n"
21715 "\n"
21716 "ARGUMENTS:\n"
21717 "\n"
21718 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21719 " viewport from the left-hand edge of the subpage in millimeters.\n"
21720 "\n"
21721 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21722 " viewport from the left-hand edge of the subpage in millimeters.\n"
21723 "\n"
21724 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21725 " viewport from the bottom edge of the subpage in millimeters.\n"
21726 "\n"
21727 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21728 " from the bottom edge of the subpage in millimeters.\n"
21729 "\n"
21730 ""},
21731 { "plsxax", _wrap_plsxax, METH_VARARGS, "\n"
21732 "Set x axis parameters\n"
21733 "\n"
21734 "DESCRIPTION:\n"
21735 "\n"
21736 " Sets values of the digmax and digits flags for the x axis. See the\n"
21737 " PLplot documentation for more information.\n"
21738 "\n"
21739 " Redacted form: plsxax(digmax, digits)\n"
21740 "\n"
21741 " This function is used in example 31.\n"
21742 "\n"
21743 "\n"
21744 "\n"
21745 "SYNOPSIS:\n"
21746 "\n"
21747 "plsxax(digmax, digits)\n"
21748 "\n"
21749 "ARGUMENTS:\n"
21750 "\n"
21751 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21752 " digits for the x axis. If nonzero, the printed label will be\n"
21753 " switched to a floating-point representation when the number of\n"
21754 " digits exceeds digmax.\n"
21755 "\n"
21756 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21757 " its value here has no effect since it is set only by plbox or\n"
21758 " plbox3. However, the user may obtain its value after a call to\n"
21759 " either of these functions by calling plgxax.\n"
21760 "\n"
21761 ""},
21762 { "plsyax", _wrap_plsyax, METH_VARARGS, "\n"
21763 "Set y axis parameters\n"
21764 "\n"
21765 "DESCRIPTION:\n"
21766 "\n"
21767 " Identical to plsxax, except that arguments are flags for y axis. See\n"
21768 " the description of plsxax for more detail.\n"
21769 "\n"
21770 " Redacted form: plsyax(digmax, digits)\n"
21771 "\n"
21772 " This function is used in examples 1, 14, and 31.\n"
21773 "\n"
21774 "\n"
21775 "\n"
21776 "SYNOPSIS:\n"
21777 "\n"
21778 "plsyax(digmax, digits)\n"
21779 "\n"
21780 "ARGUMENTS:\n"
21781 "\n"
21782 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21783 " digits for the y axis. If nonzero, the printed label will be\n"
21784 " switched to a floating-point representation when the number of\n"
21785 " digits exceeds digmax.\n"
21786 "\n"
21787 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21788 " its value here has no effect since it is set only by plbox or\n"
21789 " plbox3. However, the user may obtain its value after a call to\n"
21790 " either of these functions by calling plgyax.\n"
21791 "\n"
21792 ""},
21793 { "plsym", _wrap_plsym, METH_VARARGS, "\n"
21794 "Plot a glyph at the specified points\n"
21795 "\n"
21796 "DESCRIPTION:\n"
21797 "\n"
21798 " Plot a glyph at the specified points. (This function is largely\n"
21799 " superseded by plstring which gives access to many[!] more glyphs.)\n"
21800 "\n"
21801 " Redacted form: plsym(x, y, code)\n"
21802 "\n"
21803 " This function is used in example 7.\n"
21804 "\n"
21805 "\n"
21806 "\n"
21807 "SYNOPSIS:\n"
21808 "\n"
21809 "plsym(n, x, y, code)\n"
21810 "\n"
21811 "ARGUMENTS:\n"
21812 "\n"
21813 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21814 "\n"
21815 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21816 " the points.\n"
21817 "\n"
21818 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21819 " the points.\n"
21820 "\n"
21821 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21822 " to be plotted at each of the n points.\n"
21823 "\n"
21824 ""},
21825 { "plszax", _wrap_plszax, METH_VARARGS, "\n"
21826 "Set z axis parameters\n"
21827 "\n"
21828 "DESCRIPTION:\n"
21829 "\n"
21830 " Identical to plsxax, except that arguments are flags for z axis. See\n"
21831 " the description of plsxax for more detail.\n"
21832 "\n"
21833 " Redacted form: plszax(digmax, digits)\n"
21834 "\n"
21835 " This function is used in example 31.\n"
21836 "\n"
21837 "\n"
21838 "\n"
21839 "SYNOPSIS:\n"
21840 "\n"
21841 "plszax(digmax, digits)\n"
21842 "\n"
21843 "ARGUMENTS:\n"
21844 "\n"
21845 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21846 " digits for the z axis. If nonzero, the printed label will be\n"
21847 " switched to a floating-point representation when the number of\n"
21848 " digits exceeds digmax.\n"
21849 "\n"
21850 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21851 " its value here has no effect since it is set only by plbox or\n"
21852 " plbox3. However, the user may obtain its value after a call to\n"
21853 " either of these functions by calling plgzax.\n"
21854 "\n"
21855 ""},
21856 { "pltext", _wrap_pltext, METH_NOARGS, "\n"
21857 "Switch to text screen\n"
21858 "\n"
21859 "DESCRIPTION:\n"
21860 "\n"
21861 " Sets an interactive device to text mode, used in conjunction with\n"
21862 " plgra to allow graphics and text to be interspersed. On a device\n"
21863 " which supports separate text and graphics windows, this command causes\n"
21864 " control to be switched to the text window. This can be useful for\n"
21865 " printing diagnostic messages or getting user input, which would\n"
21866 " otherwise interfere with the plots. The program must switch back to\n"
21867 " the graphics window before issuing plot commands, as the text (or\n"
21868 " console) device will probably become quite confused otherwise. If\n"
21869 " already in text mode, this command is ignored. It is also ignored on\n"
21870 " devices which only support a single window or use a different method\n"
21871 " for shifting focus (see also plgra).\n"
21872 "\n"
21873 " Redacted form: pltext()\n"
21874 "\n"
21875 " This function is used in example 1.\n"
21876 "\n"
21877 "\n"
21878 "\n"
21879 "SYNOPSIS:\n"
21880 "\n"
21881 "pltext()\n"
21882 "\n"
21883 ""},
21884 { "pltimefmt", _wrap_pltimefmt, METH_O, "\n"
21885 "Set format for date / time labels\n"
21886 "\n"
21887 "DESCRIPTION:\n"
21888 "\n"
21889 " Sets the format for date / time labels. To enable date / time format\n"
21890 " labels see the options to plbox, plbox3, and plenv.\n"
21891 "\n"
21892 " Redacted form: pltimefmt(fmt)\n"
21893 "\n"
21894 " This function is used in example 29.\n"
21895 "\n"
21896 "\n"
21897 "\n"
21898 "SYNOPSIS:\n"
21899 "\n"
21900 "pltimefmt(fmt)\n"
21901 "\n"
21902 "ARGUMENTS:\n"
21903 "\n"
21904 " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21905 " interpreted similarly to the format specifier of typical system\n"
21906 " strftime routines except that PLplot ignores locale and also\n"
21907 " supplies some useful extensions in the context of plotting. All\n"
21908 " text in the string is printed as-is other than conversion\n"
21909 " specifications which take the form of a '%' character followed by\n"
21910 " further conversion specification character. The conversion\n"
21911 " specifications which are similar to those provided by system\n"
21912 " strftime routines are the following: %a: The abbreviated (English)\n"
21913 " weekday name.\n"
21914 " %A: The full (English) weekday name.\n"
21915 " %b: The abbreviated (English) month name.\n"
21916 " %B: The full (English) month name.\n"
21917 " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21918 " %C: The century number (year/100) as a 2-digit integer.\n"
21919 " %d: The day of the month as a decimal number (range 01 to 31).\n"
21920 " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21921 " %e: Like %d, but a leading zero is replaced by a space.\n"
21922 " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21923 " %h: Equivalent to %b.\n"
21924 " %H: The hour as a decimal number using a 24-hour clock (range\n"
21925 " 00 to 23).\n"
21926 " %I: The hour as a decimal number using a 12-hour clock (range\n"
21927 " 01 to 12).\n"
21928 " %j: The day of the year as a decimal number (range 001 to\n"
21929 " 366).\n"
21930 " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21931 " 23); single digits are preceded by a blank. (See also %H.)\n"
21932 " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21933 " 12); single digits are preceded by a blank. (See also %I.)\n"
21934 " %m: The month as a decimal number (range 01 to 12).\n"
21935 " %M: The minute as a decimal number (range 00 to 59).\n"
21936 " %n: A newline character.\n"
21937 " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21938 " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21939 " %r: Equivalent to %I:%M:%S %p.\n"
21940 " %R: The time in 24-hour notation (%H:%M). For a version\n"
21941 " including the seconds, see %T below.\n"
21942 " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21943 " +0000 (UTC).\n"
21944 " %S: The second as a decimal number (range 00 to 60). (The\n"
21945 " range is up to 60 to allow for occasional leap seconds.)\n"
21946 " %t: A tab character.\n"
21947 " %T: The time in 24-hour notation (%H:%M:%S).\n"
21948 " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21949 " being 1. See also %w.\n"
21950 " %U: The week number of the current year as a decimal number,\n"
21951 " range 00 to 53, starting with the first Sunday as the first\n"
21952 " day of week 01. See also %V and %W.\n"
21953 " %v: Equivalent to %e-%b-%Y.\n"
21954 " %V: The ISO 8601 week number of the current year as a decimal\n"
21955 " number, range 01 to 53, where week 1 is the first week that\n"
21956 " has at least 4 days in the new year. See also %U and %W.\n"
21957 " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21958 " being 0. See also %u.\n"
21959 " %W: The week number of the current year as a decimal number,\n"
21960 " range 00 to 53, starting with the first Monday as the first\n"
21961 " day of week 01.\n"
21962 " %x: Equivalent to %a %b %d %Y.\n"
21963 " %X: Equivalent to %T.\n"
21964 " %y: The year as a decimal number without a century (range 00\n"
21965 " to 99).\n"
21966 " %Y: The year as a decimal number including a century.\n"
21967 " %z: The UTC time-zone string = \"+0000\".\n"
21968 " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21969 " %+: The UTC date and time in default format of the Unix date\n"
21970 " command which is equivalent to %a %b %d %T %Z %Y.\n"
21971 " %%: A literal \"%\" character.\n"
21972 " The conversion specifications which are extensions to those normally\n"
21973 " provided by system strftime routines are the following: %(0-9):\n"
21974 " The fractional part of the seconds field (including leading\n"
21975 " decimal point) to the specified accuracy. Thus %S%3 would give\n"
21976 " seconds to millisecond accuracy (00.000).\n"
21977 " %.: The fractional part of the seconds field (including\n"
21978 " leading decimal point) to the maximum available accuracy. Thus\n"
21979 " %S%. would give seconds with fractional part up to 9 decimal\n"
21980 " places if available.\n"
21981 "\n"
21982 ""},
21983 { "plvasp", _wrap_plvasp, METH_O, "\n"
21984 "Specify viewport using aspect ratio only\n"
21985 "\n"
21986 "DESCRIPTION:\n"
21987 "\n"
21988 " Selects the largest viewport with the given aspect ratio within the\n"
21989 " subpage that leaves a standard margin (left-hand margin of eight\n"
21990 " character heights, and a margin around the other three sides of five\n"
21991 " character heights).\n"
21992 "\n"
21993 " Redacted form: plvasp(aspect)\n"
21994 "\n"
21995 " This function is used in example 13.\n"
21996 "\n"
21997 "\n"
21998 "\n"
21999 "SYNOPSIS:\n"
22000 "\n"
22001 "plvasp(aspect)\n"
22002 "\n"
22003 "ARGUMENTS:\n"
22004 "\n"
22005 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22006 " axis of resulting viewport.\n"
22007 "\n"
22008 ""},
22009 { "plvect", _wrap_plvect, METH_VARARGS, "\n"
22010 "Vector plot\n"
22011 "\n"
22012 "DESCRIPTION:\n"
22013 "\n"
22014 " Draws a plot of vector data contained in the matrices (\n"
22015 " u[\n"
22016 " nx][\n"
22017 " ny],\n"
22018 " v[\n"
22019 " nx][\n"
22020 " ny]) . The scaling factor for the vectors is given by scale. A\n"
22021 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
22022 " additional data required by the transformation routine to map indices\n"
22023 " within the matrices to the world coordinates. The style of the vector\n"
22024 " arrow may be set using plsvect.\n"
22025 "\n"
22026 " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
22027 " discussion) the pltr, pltr_data callback arguments are sometimes\n"
22028 " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
22029 " with either one or two dimensions.\n"
22030 "\n"
22031 " This function is used in example 22.\n"
22032 "\n"
22033 "\n"
22034 "\n"
22035 "SYNOPSIS:\n"
22036 "\n"
22037 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
22038 "\n"
22039 "ARGUMENTS:\n"
22040 "\n"
22041 " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
22042 " and y components of the vector data to be plotted.\n"
22043 "\n"
22044 " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
22045 "\n"
22046 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
22047 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
22048 " automatically calculated for the data. If scale < 0 then the\n"
22049 " scaling factor is automatically calculated for the data and then\n"
22050 " multiplied by -\n"
22051 " scale. If scale > 0 then the scaling factor is set to scale.\n"
22052 "\n"
22053 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22054 " defines the transformation between the zero-based indices of the\n"
22055 " matrices u and v and world coordinates.For the C case,\n"
22056 " transformation functions are provided in the PLplot library: pltr0\n"
22057 " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
22058 " mappings respectively defined by vectors and matrices. In\n"
22059 " addition, C callback routines for the transformation can be\n"
22060 " supplied by the user such as the mypltr function in\n"
22061 " examples/c/x09c.c which provides a general linear transformation\n"
22062 " between index coordinates and world coordinates.For languages\n"
22063 " other than C you should consult the PLplot documentation for the\n"
22064 " details concerning how PLTRANSFORM_callback arguments are\n"
22065 " interfaced. However, in general, a particular pattern of\n"
22066 " callback-associated arguments such as a tr vector with 6 elements;\n"
22067 " xg and yg vectors; or xg and yg matrices are respectively\n"
22068 " interfaced to a linear-transformation routine similar to the above\n"
22069 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22070 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22071 " support native language callbacks for handling index to\n"
22072 " world-coordinate transformations. Examples of these various\n"
22073 " approaches are given in examples/<language>x09*,\n"
22074 " examples/<language>x16*, examples/<language>x20*,\n"
22075 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22076 " supported languages.\n"
22077 "\n"
22078 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22079 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
22080 " that is externally supplied.\n"
22081 "\n"
22082 ""},
22083 { "plvpas", _wrap_plvpas, METH_VARARGS, "\n"
22084 "Specify viewport using coordinates and aspect ratio\n"
22085 "\n"
22086 "DESCRIPTION:\n"
22087 "\n"
22088 " Device-independent routine for setting up the viewport. The viewport\n"
22089 " is chosen to be the largest with the given aspect ratio that fits\n"
22090 " within the specified region (in terms of normalized subpage\n"
22091 " coordinates). This routine is functionally equivalent to plvpor when\n"
22092 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
22093 " routine reserves no extra space at the edges for labels.\n"
22094 "\n"
22095 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22096 "\n"
22097 " This function is used in example 9.\n"
22098 "\n"
22099 "\n"
22100 "\n"
22101 "SYNOPSIS:\n"
22102 "\n"
22103 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22104 "\n"
22105 "ARGUMENTS:\n"
22106 "\n"
22107 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22108 " left-hand edge of the viewport.\n"
22109 "\n"
22110 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22111 " right-hand edge of the viewport.\n"
22112 "\n"
22113 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22114 " bottom edge of the viewport.\n"
22115 "\n"
22116 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22117 " edge of the viewport.\n"
22118 "\n"
22119 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22120 " axis.\n"
22121 "\n"
22122 ""},
22123 { "plvpor", _wrap_plvpor, METH_VARARGS, "\n"
22124 "Specify viewport using normalized subpage coordinates\n"
22125 "\n"
22126 "DESCRIPTION:\n"
22127 "\n"
22128 " Device-independent routine for setting up the viewport. This defines\n"
22129 " the viewport in terms of normalized subpage coordinates which run from\n"
22130 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
22131 " current subpage. Use the alternate routine plsvpa in order to create\n"
22132 " a viewport of a definite size.\n"
22133 "\n"
22134 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
22135 "\n"
22136 " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
22137 " 24, 26, 27, and 31.\n"
22138 "\n"
22139 "\n"
22140 "\n"
22141 "SYNOPSIS:\n"
22142 "\n"
22143 "plvpor(xmin, xmax, ymin, ymax)\n"
22144 "\n"
22145 "ARGUMENTS:\n"
22146 "\n"
22147 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22148 " left-hand edge of the viewport.\n"
22149 "\n"
22150 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22151 " right-hand edge of the viewport.\n"
22152 "\n"
22153 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22154 " bottom edge of the viewport.\n"
22155 "\n"
22156 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22157 " edge of the viewport.\n"
22158 "\n"
22159 ""},
22160 { "plvsta", _wrap_plvsta, METH_NOARGS, "\n"
22161 "Select standard viewport\n"
22162 "\n"
22163 "DESCRIPTION:\n"
22164 "\n"
22165 " Selects the largest viewport within the subpage that leaves a standard\n"
22166 " margin (left-hand margin of eight character heights, and a margin\n"
22167 " around the other three sides of five character heights).\n"
22168 "\n"
22169 " Redacted form: plvsta()\n"
22170 "\n"
22171 " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
22172 "\n"
22173 "\n"
22174 "\n"
22175 "SYNOPSIS:\n"
22176 "\n"
22177 "plvsta()\n"
22178 "\n"
22179 ""},
22180 { "plw3d", _wrap_plw3d, METH_VARARGS, "\n"
22181 "Configure the transformations required for projecting a 3D surface on a 2D window\n"
22182 "\n"
22183 "DESCRIPTION:\n"
22184 "\n"
22185 " Configure the transformations required for projecting a 3D surface on\n"
22186 " an existing 2D window. Those transformations (see the PLplot\n"
22187 " documentation) are done to a rectangular cuboid enclosing the 3D\n"
22188 " surface which has its limits expressed in 3D world coordinates and\n"
22189 " also normalized 3D coordinates (used for interpreting the altitude and\n"
22190 " azimuth of the viewing angle). The transformations consist of the\n"
22191 " linear transform from 3D world coordinates to normalized 3D\n"
22192 " coordinates, and the 3D rotation of normalized coordinates required to\n"
22193 " align the pole of the new 3D coordinate system with the viewing\n"
22194 " direction specified by altitude and azimuth so that x and y of the\n"
22195 " surface elements in that transformed coordinate system are the\n"
22196 " projection of the 3D surface with given viewing direction on the 2D\n"
22197 " window.\n"
22198 "\n"
22199 " The enclosing rectangular cuboid for the surface plot is defined by\n"
22200 " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
22201 " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
22202 " sizes of basex by basey by height so that xmin maps to -\n"
22203 " basex/2, xmax maps to basex/2, ymin maps to -\n"
22204 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
22205 " The resulting rectangular cuboid in normalized coordinates is then\n"
22206 " viewed by an observer at altitude alt and azimuth az. This routine\n"
22207 " must be called before plbox3 or any of the 3D surface plotting\n"
22208 " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
22209 " plsurf3dl or plfill3.\n"
22210 "\n"
22211 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
22212 " zmin, zmax, alt, az)\n"
22213 "\n"
22214 " This function is examples 8, 11, 18, and 21.\n"
22215 "\n"
22216 "\n"
22217 "\n"
22218 "SYNOPSIS:\n"
22219 "\n"
22220 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
22221 "\n"
22222 "ARGUMENTS:\n"
22223 "\n"
22224 " basex (PLFLT, input) : The normalized x coordinate size of the\n"
22225 " rectangular cuboid.\n"
22226 "\n"
22227 " basey (PLFLT, input) : The normalized y coordinate size of the\n"
22228 " rectangular cuboid.\n"
22229 "\n"
22230 " height (PLFLT, input) : The normalized z coordinate size of the\n"
22231 " rectangular cuboid.\n"
22232 "\n"
22233 " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
22234 " rectangular cuboid.\n"
22235 "\n"
22236 " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
22237 " rectangular cuboid.\n"
22238 "\n"
22239 " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
22240 " rectangular cuboid.\n"
22241 "\n"
22242 " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
22243 " rectangular cuboid.\n"
22244 "\n"
22245 " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
22246 " rectangular cuboid.\n"
22247 "\n"
22248 " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
22249 " rectangular cuboid.\n"
22250 "\n"
22251 " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
22252 " plane of the rectangular cuboid in normalized coordinates.\n"
22253 "\n"
22254 " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
22255 " rectangular cuboid in normalized coordinates. When az=0, the\n"
22256 " observer is looking face onto the zx plane of the rectangular\n"
22257 " cuboid in normalized coordinates, and as az is increased, the\n"
22258 " observer moves clockwise around that cuboid when viewed from above\n"
22259 " the xy plane.\n"
22260 "\n"
22261 ""},
22262 { "plwidth", _wrap_plwidth, METH_O, "\n"
22263 "Set pen width\n"
22264 "\n"
22265 "DESCRIPTION:\n"
22266 "\n"
22267 " Sets the pen width.\n"
22268 "\n"
22269 " Redacted form: plwidth(width)\n"
22270 "\n"
22271 " This function is used in examples 1 and 2.\n"
22272 "\n"
22273 "\n"
22274 "\n"
22275 "SYNOPSIS:\n"
22276 "\n"
22277 "plwidth(width)\n"
22278 "\n"
22279 "ARGUMENTS:\n"
22280 "\n"
22281 " width (PLFLT, input) : The desired pen width. If width is negative\n"
22282 " or the same as the previous value no action is taken. width = 0.\n"
22283 " should be interpreted as as the minimum valid pen width for the\n"
22284 " device. The interpretation of positive width values is also\n"
22285 " device dependent.\n"
22286 "\n"
22287 ""},
22288 { "plwind", _wrap_plwind, METH_VARARGS, "\n"
22289 "Specify window\n"
22290 "\n"
22291 "DESCRIPTION:\n"
22292 "\n"
22293 " Specify the window, i.e., the world coordinates of the edges of the\n"
22294 " viewport.\n"
22295 "\n"
22296 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
22297 "\n"
22298 " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
22299 " 29, and 31.\n"
22300 "\n"
22301 "\n"
22302 "\n"
22303 "SYNOPSIS:\n"
22304 "\n"
22305 "plwind(xmin, xmax, ymin, ymax)\n"
22306 "\n"
22307 "ARGUMENTS:\n"
22308 "\n"
22309 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
22310 " of the viewport.\n"
22311 "\n"
22312 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
22313 " of the viewport.\n"
22314 "\n"
22315 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
22316 " the viewport.\n"
22317 "\n"
22318 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
22319 " viewport.\n"
22320 "\n"
22321 ""},
22322 { "plxormod", _wrap_plxormod, METH_O, "\n"
22323 "Enter or leave xor mode\n"
22324 "\n"
22325 "DESCRIPTION:\n"
22326 "\n"
22327 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
22328 " those drivers (e.g., the xwin driver) that support it. Enables\n"
22329 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
22330 " is not capable of xor operation it returns a status of false.\n"
22331 "\n"
22332 " Redacted form: plxormod(mode, status)\n"
22333 "\n"
22334 " This function is used in examples 1 and 20.\n"
22335 "\n"
22336 "\n"
22337 "\n"
22338 "SYNOPSIS:\n"
22339 "\n"
22340 "plxormod(mode, status)\n"
22341 "\n"
22342 "ARGUMENTS:\n"
22343 "\n"
22344 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
22345 " is false means leave xor mode.\n"
22346 "\n"
22347 " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
22348 " modestatus of true (false) means driver is capable (incapable) of\n"
22349 " xor mode.\n"
22350 "\n"
22351 ""},
22352 { "plmap", _wrap_plmap, METH_VARARGS, "\n"
22353 "Plot continental outline or shapefile data in world coordinates\n"
22354 "\n"
22355 "DESCRIPTION:\n"
22356 "\n"
22357 " Plots continental outlines or shapefile data in world coordinates. A\n"
22358 " demonstration of how to use this function to create different\n"
22359 " projections can be found in examples/c/x19c. PLplot is provided with\n"
22360 " basic coastal outlines and USA state borders. To use the map\n"
22361 " functionality PLplot must be compiled with the shapelib library.\n"
22362 " Shapefiles have become a popular standard for geographical data and\n"
22363 " data in this format can be easily found from a number of online\n"
22364 " sources. Shapefile data is actually provided as three or more files\n"
22365 " with the same filename, but different extensions. The .shp and .shx\n"
22366 " files are required for plotting Shapefile data with PLplot.\n"
22367 "\n"
22368 " PLplot currently supports the point, multipoint, polyline and polygon\n"
22369 " objects within shapefiles. However holes in polygons are not\n"
22370 " supported. When plmap is used the type of object is derived from the\n"
22371 " shapefile, if you wish to override the type then use one of the other\n"
22372 " plmap variants. The built in maps have line data only.\n"
22373 "\n"
22374 " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
22375 "\n"
22376 " This function is used in example 19.\n"
22377 "\n"
22378 "\n"
22379 "\n"
22380 "SYNOPSIS:\n"
22381 "\n"
22382 "plmap(mapform, name, minx, maxx, miny, maxy)\n"
22383 "\n"
22384 "ARGUMENTS:\n"
22385 "\n"
22386 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22387 " transform the original map data coordinates to a new coordinate\n"
22388 " system. The PLplot-supplied map data is provided as latitudes and\n"
22389 " longitudes; other Shapefile data may be provided in other\n"
22390 " coordinate systems as can be found in their .prj plain text files.\n"
22391 " For example, by using this transform we can change from a\n"
22392 " longitude, latitude coordinate to a polar stereographic\n"
22393 " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
22394 " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
22395 " corresponding y coordinates (latitudes for the PLplot supplied\n"
22396 " data). After the call to mapform(), x[] and y[] should be\n"
22397 " replaced by the corresponding plot coordinates. If no transform is\n"
22398 " desired, mapform can be replaced by NULL.\n"
22399 "\n"
22400 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22401 " the type of map plotted. This is either one of the PLplot built-in\n"
22402 " maps or the file name of a set of Shapefile files without the file\n"
22403 " extensions. For the PLplot built-in maps the possible values are:\n"
22404 " \"globe\" -- continental outlines\n"
22405 " \"usa\" -- USA and state boundaries\n"
22406 " \"cglobe\" -- continental outlines and countries\n"
22407 " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
22408 "\n"
22409 "\n"
22410 " minx (PLFLT, input) : The minimum x value of map elements to be\n"
22411 " drawn. The units must match the shapefile (built in maps are\n"
22412 " degrees lat/lon). Objects in the file which do not encroach on the\n"
22413 " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
22414 " note this is simply an optimisation, not a clipping so for objects\n"
22415 " with some points inside the box and some points outside the box\n"
22416 " all the points will be rendered. These parameters also define\n"
22417 " latitude and longitude wrapping for shapefiles using these units.\n"
22418 " Longitude points will be wrapped by integer multiples of 360\n"
22419 " degrees to place them in the box. This allows the same data to be\n"
22420 " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
22421 " you plot from -180-540 you will get two cycles of data drawn. The\n"
22422 " value of minx must be less than the value of maxx. Passing in a\n"
22423 " nan, max/-max floating point number or +/-infinity will case the\n"
22424 " bounding box from the shapefile to be used.\n"
22425 "\n"
22426 " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22427 " drawn - see minx.\n"
22428 "\n"
22429 " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22430 " drawn - see minx.\n"
22431 "\n"
22432 " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22433 " drawn - see minx.\n"
22434 "\n"
22435 ""},
22436 { "plmapline", _wrap_plmapline, METH_VARARGS, "\n"
22437 "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22438 "\n"
22439 "DESCRIPTION:\n"
22440 "\n"
22441 " Plot all or a subset of Shapefile data using lines in world\n"
22442 " coordinates. Our 19th standard example demonstrates how to use this\n"
22443 " function. This function plots data from a Shapefile using lines as in\n"
22444 " plmap, however it also has the option of also only drawing specified\n"
22445 " elements from the Shapefile. The vector of indices of the required\n"
22446 " elements are passed as a function argument. The Shapefile data should\n"
22447 " include a metadata file (extension.dbf) listing all items within the\n"
22448 " Shapefile. This file can be opened by most popular spreadsheet\n"
22449 " programs and can be used to decide which indices to pass to this\n"
22450 " function.\n"
22451 "\n"
22452 " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22453 " plotentries)\n"
22454 "\n"
22455 " This function is used in example 19.\n"
22456 "\n"
22457 "\n"
22458 "\n"
22459 "SYNOPSIS:\n"
22460 "\n"
22461 "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22462 "\n"
22463 "ARGUMENTS:\n"
22464 "\n"
22465 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22466 " transform the coordinates given in the shapefile into a plot\n"
22467 " coordinate system. By using this transform, we can change from a\n"
22468 " longitude, latitude coordinate to a polar stereographic project,\n"
22469 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22470 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22471 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22472 " plot coordinates. If no transform is desired, mapform can be\n"
22473 " replaced by NULL.\n"
22474 "\n"
22475 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22476 " the file name of a set of Shapefile files without the file\n"
22477 " extension.\n"
22478 "\n"
22479 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22480 " be in the same units as used by the Shapefile. You could use a\n"
22481 " very large negative number to plot everything, but you can improve\n"
22482 " performance by limiting the area drawn. The units must match those\n"
22483 " of the Shapefile projection, which may be for example longitude or\n"
22484 " distance. The value of minx must be less than the value of maxx.\n"
22485 "\n"
22486 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22487 " use a very large number to plot everything, but you can improve\n"
22488 " performance by limiting the area drawn.\n"
22489 "\n"
22490 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22491 " be in the same units as used by the Shapefile. You could use a\n"
22492 " very large negative number to plot everything, but you can improve\n"
22493 " performance by limiting the area drawn. The units must match those\n"
22494 " of the Shapefile projection, which may be for example latitude or\n"
22495 " distance. The value of miny must be less than the value of maxy.\n"
22496 "\n"
22497 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22498 " use a very large number to plot everything, but you can improve\n"
22499 " performance by limiting the area drawn.\n"
22500 "\n"
22501 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22502 " zero-based indices of the Shapefile elements which will be drawn.\n"
22503 " Setting\n"
22504 " plotentries to NULL will plot all elements of the Shapefile.\n"
22505 "\n"
22506 " nplotentries (PLINT, input) : The number of items in\n"
22507 " plotentries. Ignored if\n"
22508 " plotentries is NULL.\n"
22509 "\n"
22510 ""},
22511 { "plmapstring", _wrap_plmapstring, METH_VARARGS, "\n"
22512 "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22513 "\n"
22514 "DESCRIPTION:\n"
22515 "\n"
22516 " As per plmapline, however the items are plotted as strings or points\n"
22517 " in the same way as plstring.\n"
22518 "\n"
22519 " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22520 " maxy, plotentries)\n"
22521 "\n"
22522 " This function is not used in any examples.\n"
22523 "\n"
22524 "\n"
22525 "\n"
22526 "SYNOPSIS:\n"
22527 "\n"
22528 "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22529 "\n"
22530 "ARGUMENTS:\n"
22531 "\n"
22532 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22533 " transform the coordinates given in the shapefile into a plot\n"
22534 " coordinate system. By using this transform, we can change from a\n"
22535 " longitude, latitude coordinate to a polar stereographic project,\n"
22536 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22537 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22538 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22539 " plot coordinates. If no transform is desired, mapform can be\n"
22540 " replaced by NULL.\n"
22541 "\n"
22542 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22543 " the file name of a set of Shapefile files without the file\n"
22544 " extension.\n"
22545 "\n"
22546 " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22547 " drawn.\n"
22548 "\n"
22549 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22550 " be in the same units as used by the Shapefile. You could use a\n"
22551 " very large negative number to plot everything, but you can improve\n"
22552 " performance by limiting the area drawn. The units must match those\n"
22553 " of the Shapefile projection, which may be for example longitude or\n"
22554 " distance. The value of minx must be less than the value of maxx.\n"
22555 "\n"
22556 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22557 " use a very large number to plot everything, but you can improve\n"
22558 " performance by limiting the area drawn.\n"
22559 "\n"
22560 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22561 " be in the same units as used by the Shapefile. You could use a\n"
22562 " very large negative number to plot everything, but you can improve\n"
22563 " performance by limiting the area drawn. The units must match those\n"
22564 " of the Shapefile projection, which may be for example latitude or\n"
22565 " distance. The value of miny must be less than the value of maxy.\n"
22566 "\n"
22567 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22568 " use a very large number to plot everything, but you can improve\n"
22569 " performance by limiting the area drawn.\n"
22570 "\n"
22571 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22572 " zero-based indices of the Shapefile elements which will be drawn.\n"
22573 " Setting\n"
22574 " plotentries to NULL will plot all elements of the Shapefile.\n"
22575 "\n"
22576 " nplotentries (PLINT, input) : The number of items in\n"
22577 " plotentries. Ignored if\n"
22578 " plotentries is NULL.\n"
22579 "\n"
22580 ""},
22581 { "plmaptex", _wrap_plmaptex, METH_VARARGS, "\n"
22582 "Draw text at points defined by Shapefile data in world coordinates\n"
22583 "\n"
22584 "DESCRIPTION:\n"
22585 "\n"
22586 " As per plmapline, however the items are plotted as text in the same\n"
22587 " way as plptex.\n"
22588 "\n"
22589 " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22590 " miny, maxy, plotentry)\n"
22591 "\n"
22592 " This function is used in example 19.\n"
22593 "\n"
22594 "\n"
22595 "\n"
22596 "SYNOPSIS:\n"
22597 "\n"
22598 "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22599 "\n"
22600 "ARGUMENTS:\n"
22601 "\n"
22602 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22603 " transform the coordinates given in the shapefile into a plot\n"
22604 " coordinate system. By using this transform, we can change from a\n"
22605 " longitude, latitude coordinate to a polar stereographic project,\n"
22606 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22607 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22608 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22609 " plot coordinates. If no transform is desired, mapform can be\n"
22610 " replaced by NULL.\n"
22611 "\n"
22612 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22613 " the file name of a set of Shapefile files without the file\n"
22614 " extension.\n"
22615 "\n"
22616 " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22617 " dy/dx.\n"
22618 "\n"
22619 " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22620 " dy/dx.\n"
22621 "\n"
22622 " just (PLFLT, input) : Set the justification of the text. The value\n"
22623 " given will be the fraction of the distance along the string that\n"
22624 " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22625 " centralized text and 1.0 gives right aligned text.\n"
22626 "\n"
22627 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22628 "\n"
22629 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22630 " be in the same units as used by the Shapefile. You could use a\n"
22631 " very large negative number to plot everything, but you can improve\n"
22632 " performance by limiting the area drawn. The units must match those\n"
22633 " of the Shapefile projection, which may be for example longitude or\n"
22634 " distance. The value of minx must be less than the value of maxx.\n"
22635 "\n"
22636 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22637 " use a very large number to plot everything, but you can improve\n"
22638 " performance by limiting the area drawn.\n"
22639 "\n"
22640 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22641 " be in the same units as used by the Shapefile. You could use a\n"
22642 " very large negative number to plot everything, but you can improve\n"
22643 " performance by limiting the area drawn. The units must match those\n"
22644 " of the Shapefile projection, which may be for example latitude or\n"
22645 " distance. The value of miny must be less than the value of maxy.\n"
22646 "\n"
22647 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22648 " use a very large number to plot everything, but you can improve\n"
22649 " performance by limiting the area drawn.\n"
22650 "\n"
22651 " plotentry (PLINT, input) : An integer indicating which text string\n"
22652 " of the Shapefile (zero indexed) will be drawn.\n"
22653 "\n"
22654 ""},
22655 { "plmapfill", _wrap_plmapfill, METH_VARARGS, "\n"
22656 "Plot all or a subset of Shapefile data, filling the polygons\n"
22657 "\n"
22658 "DESCRIPTION:\n"
22659 "\n"
22660 " As per plmapline, however the items are filled in the same way as\n"
22661 " plfill.\n"
22662 "\n"
22663 " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22664 " plotentries)\n"
22665 "\n"
22666 " This function is used in example 19.\n"
22667 "\n"
22668 "\n"
22669 "\n"
22670 "SYNOPSIS:\n"
22671 "\n"
22672 "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22673 "\n"
22674 "ARGUMENTS:\n"
22675 "\n"
22676 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22677 " transform the coordinates given in the shapefile into a plot\n"
22678 " coordinate system. By using this transform, we can change from a\n"
22679 " longitude, latitude coordinate to a polar stereographic project,\n"
22680 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22681 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22682 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22683 " plot coordinates. If no transform is desired, mapform can be\n"
22684 " replaced by NULL.\n"
22685 "\n"
22686 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22687 " the file name of a set of Shapefile files without the file\n"
22688 " extension.\n"
22689 "\n"
22690 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22691 " be in the same units as used by the Shapefile. You could use a\n"
22692 " very large negative number to plot everything, but you can improve\n"
22693 " performance by limiting the area drawn. The units must match those\n"
22694 " of the Shapefile projection, which may be for example longitude or\n"
22695 " distance. The value of minx must be less than the value of maxx.\n"
22696 "\n"
22697 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22698 " use a very large number to plot everything, but you can improve\n"
22699 " performance by limiting the area drawn.\n"
22700 "\n"
22701 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22702 " be in the same units as used by the Shapefile. You could use a\n"
22703 " very large negative number to plot everything, but you can improve\n"
22704 " performance by limiting the area drawn. The units must match those\n"
22705 " of the Shapefile projection, which may be for example latitude or\n"
22706 " distance. The value of miny must be less than the value of maxy.\n"
22707 "\n"
22708 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22709 " use a very large number to plot everything, but you can improve\n"
22710 " performance by limiting the area drawn.\n"
22711 "\n"
22712 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22713 " zero-based indices of the Shapefile elements which will be drawn.\n"
22714 " Setting\n"
22715 " plotentries to NULL will plot all elements of the Shapefile.\n"
22716 "\n"
22717 " nplotentries (PLINT, input) : The number of items in\n"
22718 " plotentries. Ignored if\n"
22719 " plotentries is NULL.\n"
22720 "\n"
22721 ""},
22722 { "plmeridians", _wrap_plmeridians, METH_VARARGS, "\n"
22723 "Plot latitude and longitude lines\n"
22724 "\n"
22725 "DESCRIPTION:\n"
22726 "\n"
22727 " Displays latitude and longitude on the current plot. The lines are\n"
22728 " plotted in the current color and line style.\n"
22729 "\n"
22730 " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22731 " minlat, maxlat)\n"
22732 "\n"
22733 " This function is used in example 19.\n"
22734 "\n"
22735 "\n"
22736 "\n"
22737 "SYNOPSIS:\n"
22738 "\n"
22739 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22740 "\n"
22741 "ARGUMENTS:\n"
22742 "\n"
22743 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22744 " transform the coordinate longitudes and latitudes to a plot\n"
22745 " coordinate system. By using this transform, we can change from a\n"
22746 " longitude, latitude coordinate to a polar stereographic project,\n"
22747 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22748 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22749 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22750 " plot coordinates. If no transform is desired, mapform can be\n"
22751 " replaced by NULL.\n"
22752 "\n"
22753 " dlong (PLFLT, input) : The interval in degrees at which the\n"
22754 " longitude lines are to be plotted.\n"
22755 "\n"
22756 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22757 " lines are to be plotted.\n"
22758 "\n"
22759 " minlong (PLFLT, input) : The value of the longitude on the left\n"
22760 " side of the plot. The value of minlong must be less than the value\n"
22761 " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22762 " equal to 360.\n"
22763 "\n"
22764 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22765 " side of the plot.\n"
22766 "\n"
22767 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22768 " background. One can always use -90.0 as the boundary outside the\n"
22769 " plot window will be automatically eliminated. However, the\n"
22770 " program will be faster if one can reduce the size of the\n"
22771 " background plotted.\n"
22772 "\n"
22773 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22774 " background. One can always use 90.0 as the boundary outside the\n"
22775 " plot window will be automatically eliminated.\n"
22776 "\n"
22777 ""},
22778 { "plimage", _wrap_plimage, METH_VARARGS, "\n"
22779 "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22780 "\n"
22781 "DESCRIPTION:\n"
22782 "\n"
22783 " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22784 " automatically adjusted to use the maximum and minimum values in idata\n"
22785 " as valuemin and valuemax in a call to plimagefr.\n"
22786 "\n"
22787 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22788 " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22789 "\n"
22790 "\n"
22791 " This function is used in example 20.\n"
22792 "\n"
22793 "\n"
22794 "\n"
22795 "SYNOPSIS:\n"
22796 "\n"
22797 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22798 "\n"
22799 "ARGUMENTS:\n"
22800 "\n"
22801 " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22802 " to plot. Should have dimensions of\n"
22803 " nx by\n"
22804 " ny.\n"
22805 "\n"
22806 " nx, ny (PLINT, input) : Dimensions of idata\n"
22807 "\n"
22808 " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22809 " are linearly transformed to these world coordinate ranges such\n"
22810 " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22811 " - 1] corresponds to (xmax, ymax).\n"
22812 "\n"
22813 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22814 " (inclusive) will be plotted.\n"
22815 "\n"
22816 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22817 " points whose plot coordinates fall inside the window of (Dxmin,\n"
22818 " Dymin) to (Dxmax, Dymax).\n"
22819 "\n"
22820 ""},
22821 { "plimagefr", _wrap_plimagefr, METH_VARARGS, "\n"
22822 "Plot a 2D matrix using cmap1\n"
22823 "\n"
22824 "DESCRIPTION:\n"
22825 "\n"
22826 " Plot a 2D matrix using cmap1.\n"
22827 "\n"
22828 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22829 " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22830 "\n"
22831 "\n"
22832 " This function is used in example 20.\n"
22833 "\n"
22834 "\n"
22835 "\n"
22836 "SYNOPSIS:\n"
22837 "\n"
22838 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22839 "\n"
22840 "ARGUMENTS:\n"
22841 "\n"
22842 " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22843 " plot. Should have dimensions of\n"
22844 " nx by\n"
22845 " ny.\n"
22846 "\n"
22847 " nx, ny (PLINT, input) : Dimensions of idata\n"
22848 "\n"
22849 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22850 " pltr below for how these arguments are used (only for the special case\n"
22851 " when the callback function\n"
22852 " pltr is not supplied).\n"
22853 "\n"
22854 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22855 " (inclusive) will be plotted.\n"
22856 "\n"
22857 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22858 " values to use for value to color mappings. A datum equal to or\n"
22859 " less than valuemin will be plotted with color 0.0, while a datum\n"
22860 " equal to or greater than valuemax will be plotted with color 1.0.\n"
22861 " Data between valuemin and valuemax map linearly to colors in the\n"
22862 " range (0.0-1.0).\n"
22863 "\n"
22864 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22865 " defines the transformation between the zero-based indices of the\n"
22866 " matrix idata and world coordinates. If\n"
22867 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22868 " indices of idata are mapped to the range\n"
22869 " xmin through\n"
22870 " xmax and the y indices of idata are mapped to the range\n"
22871 " ymin through\n"
22872 " ymax.For the C case, transformation functions are provided in the\n"
22873 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22874 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22875 " matrices. In addition, C callback routines for the transformation\n"
22876 " can be supplied by the user such as the mypltr function in\n"
22877 " examples/c/x09c.c which provides a general linear transformation\n"
22878 " between index coordinates and world coordinates.For languages\n"
22879 " other than C you should consult the PLplot documentation for the\n"
22880 " details concerning how PLTRANSFORM_callback arguments are\n"
22881 " interfaced. However, in general, a particular pattern of\n"
22882 " callback-associated arguments such as a tr vector with 6 elements;\n"
22883 " xg and yg vectors; or xg and yg matrices are respectively\n"
22884 " interfaced to a linear-transformation routine similar to the above\n"
22885 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22886 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22887 " support native language callbacks for handling index to\n"
22888 " world-coordinate transformations. Examples of these various\n"
22889 " approaches are given in examples/<language>x09*,\n"
22890 " examples/<language>x16*, examples/<language>x20*,\n"
22891 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22892 " supported languages.\n"
22893 "\n"
22894 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22895 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22896 " externally supplied.\n"
22897 "\n"
22898 ""},
22899 { "plClearOpts", _wrap_plClearOpts, METH_NOARGS, NULL},
22900 { "plResetOpts", _wrap_plResetOpts, METH_NOARGS, NULL},
22901 { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22902 { "plOptUsage", _wrap_plOptUsage, METH_NOARGS, NULL},
22903 { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_O, NULL},
22904 { "plGetCursor", _wrap_plGetCursor, METH_O, "\n"
22905 "Wait for graphics input event and translate to world coordinates.\n"
22906 "\n"
22907 "DESCRIPTION:\n"
22908 "\n"
22909 " Wait for graphics input event and translate to world coordinates.\n"
22910 " Returns 0 if no translation to world coordinates is possible.\n"
22911 "\n"
22912 " This function returns 1 on success and 0 if no translation to world\n"
22913 " coordinates is possible.\n"
22914 "\n"
22915 " Redacted form: plGetCursor(gin)\n"
22916 "\n"
22917 " This function is used in examples 1 and 20.\n"
22918 "\n"
22919 "\n"
22920 "\n"
22921 "SYNOPSIS:\n"
22922 "\n"
22923 "PLINT plGetCursor(gin)\n"
22924 "\n"
22925 "ARGUMENTS:\n"
22926 "\n"
22927 " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22928 " which will contain the output. The structure is not allocated by\n"
22929 " the routine and must exist before the function is called.\n"
22930 "\n"
22931 ""},
22932 { NULL, NULL, 0, NULL }
22933};
22934
22935
22936/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22937
22938static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22939static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22940static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22941static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22942static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
22943static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
22944static 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};
22945static 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};
22946static 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};
22947static 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};
22948static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
22949static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22950static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22951static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
22952
22969
22970static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22971static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22972static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22973static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22974static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
22980static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22981static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
22982static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
22983static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22984
23001
23002
23003/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23004
23006{0, 0, 0, 0.0, 0, 0}};
23007
23008#ifdef __cplusplus
23009}
23010#endif
23011/* -----------------------------------------------------------------------------
23012 * Type initialization:
23013 * This problem is tough by the requirement that no dynamic
23014 * memory is used. Also, since swig_type_info structures store pointers to
23015 * swig_cast_info structures and swig_cast_info structures store pointers back
23016 * to swig_type_info structures, we need some lookup code at initialization.
23017 * The idea is that swig generates all the structures that are needed.
23018 * The runtime then collects these partially filled structures.
23019 * The SWIG_InitializeModule function takes these initial arrays out of
23020 * swig_module, and does all the lookup, filling in the swig_module.types
23021 * array with the correct data and linking the correct swig_cast_info
23022 * structures together.
23023 *
23024 * The generated swig_type_info structures are assigned statically to an initial
23025 * array. We just loop through that array, and handle each type individually.
23026 * First we lookup if this type has been already loaded, and if so, use the
23027 * loaded structure instead of the generated one. Then we have to fill in the
23028 * cast linked list. The cast data is initially stored in something like a
23029 * two-dimensional array. Each row corresponds to a type (there are the same
23030 * number of rows as there are in the swig_type_initial array). Each entry in
23031 * a column is one of the swig_cast_info structures for that type.
23032 * The cast_initial array is actually an array of arrays, because each row has
23033 * a variable number of columns. So to actually build the cast linked list,
23034 * we find the array of casts associated with the type, and loop through it
23035 * adding the casts to the list. The one last trick we need to do is making
23036 * sure the type pointer in the swig_cast_info struct is correct.
23037 *
23038 * First off, we lookup the cast->type name to see if it is already loaded.
23039 * There are three cases to handle:
23040 * 1) If the cast->type has already been loaded AND the type we are adding
23041 * casting info to has not been loaded (it is in this module), THEN we
23042 * replace the cast->type pointer with the type pointer that has already
23043 * been loaded.
23044 * 2) If BOTH types (the one we are adding casting info to, and the
23045 * cast->type) are loaded, THEN the cast info has already been loaded by
23046 * the previous module so we just ignore it.
23047 * 3) Finally, if cast->type has not already been loaded, then we add that
23048 * swig_cast_info to the linked list (because the cast->type) pointer will
23049 * be correct.
23050 * ----------------------------------------------------------------------------- */
23051
23052#ifdef __cplusplus
23053extern "C" {
23054#if 0
23055} /* c-mode */
23056#endif
23057#endif
23058
23059#if 0
23060#define SWIGRUNTIME_DEBUG
23061#endif
23062
23063#ifndef SWIG_INIT_CLIENT_DATA_TYPE
23064#define SWIG_INIT_CLIENT_DATA_TYPE void *
23065#endif
23066
23067SWIGRUNTIME void
23069 size_t i;
23070 swig_module_info *module_head, *iter;
23071 int init;
23072
23073 /* check to see if the circular list has been setup, if not, set it up */
23074 if (swig_module.next==0) {
23075 /* Initialize the swig_module */
23079 init = 1;
23080 } else {
23081 init = 0;
23082 }
23083
23084 /* Try and load any already created modules */
23085 module_head = SWIG_GetModule(clientdata);
23086 if (!module_head) {
23087 /* This is the first module loaded for this interpreter */
23088 /* so set the swig module into the interpreter */
23089 SWIG_SetModule(clientdata, &swig_module);
23090 } else {
23091 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
23092 iter=module_head;
23093 do {
23094 if (iter==&swig_module) {
23095 /* Our module is already in the list, so there's nothing more to do. */
23096 return;
23097 }
23098 iter=iter->next;
23099 } while (iter!= module_head);
23100
23101 /* otherwise we must add our module into the list */
23102 swig_module.next = module_head->next;
23103 module_head->next = &swig_module;
23104 }
23105
23106 /* When multiple interpreters are used, a module could have already been initialized in
23107 a different interpreter, but not yet have a pointer in this interpreter.
23108 In this case, we do not want to continue adding types... everything should be
23109 set up already */
23110 if (init == 0) return;
23111
23112 /* Now work on filling in swig_module.types */
23113#ifdef SWIGRUNTIME_DEBUG
23114 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
23115#endif
23116 for (i = 0; i < swig_module.size; ++i) {
23117 swig_type_info *type = 0;
23118 swig_type_info *ret;
23119 swig_cast_info *cast;
23120
23121#ifdef SWIGRUNTIME_DEBUG
23122 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23123#endif
23124
23125 /* if there is another module already loaded */
23126 if (swig_module.next != &swig_module) {
23128 }
23129 if (type) {
23130 /* Overwrite clientdata field */
23131#ifdef SWIGRUNTIME_DEBUG
23132 printf("SWIG_InitializeModule: found type %s\n", type->name);
23133#endif
23135 type->clientdata = swig_module.type_initial[i]->clientdata;
23136#ifdef SWIGRUNTIME_DEBUG
23137 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23138#endif
23139 }
23140 } else {
23141 type = swig_module.type_initial[i];
23142 }
23143
23144 /* Insert casting types */
23145 cast = swig_module.cast_initial[i];
23146 while (cast->type) {
23147 /* Don't need to add information already in the list */
23148 ret = 0;
23149#ifdef SWIGRUNTIME_DEBUG
23150 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23151#endif
23152 if (swig_module.next != &swig_module) {
23154#ifdef SWIGRUNTIME_DEBUG
23155 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23156#endif
23157 }
23158 if (ret) {
23159 if (type == swig_module.type_initial[i]) {
23160#ifdef SWIGRUNTIME_DEBUG
23161 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23162#endif
23163 cast->type = ret;
23164 ret = 0;
23165 } else {
23166 /* Check for casting already in the list */
23167 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23168#ifdef SWIGRUNTIME_DEBUG
23169 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23170#endif
23171 if (!ocast) ret = 0;
23172 }
23173 }
23174
23175 if (!ret) {
23176#ifdef SWIGRUNTIME_DEBUG
23177 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23178#endif
23179 if (type->cast) {
23180 type->cast->prev = cast;
23181 cast->next = type->cast;
23182 }
23183 type->cast = cast;
23184 }
23185 cast++;
23186 }
23187 /* Set entry in modules->types array equal to the type */
23188 swig_module.types[i] = type;
23189 }
23190 swig_module.types[i] = 0;
23191
23192#ifdef SWIGRUNTIME_DEBUG
23193 printf("**** SWIG_InitializeModule: Cast List ******\n");
23194 for (i = 0; i < swig_module.size; ++i) {
23195 int j = 0;
23197 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23198 while (cast->type) {
23199 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23200 cast++;
23201 ++j;
23202 }
23203 printf("---- Total casts: %d\n",j);
23204 }
23205 printf("**** SWIG_InitializeModule: Cast List ******\n");
23206#endif
23207}
23208
23209/* This function will propagate the clientdata field of type to
23210* any new swig_type_info structures that have been added into the list
23211* of equivalent types. It is like calling
23212* SWIG_TypeClientData(type, clientdata) a second time.
23213*/
23214SWIGRUNTIME void
23216 size_t i;
23217 swig_cast_info *equiv;
23218 static int init_run = 0;
23219
23220 if (init_run) return;
23221 init_run = 1;
23222
23223 for (i = 0; i < swig_module.size; i++) {
23224 if (swig_module.types[i]->clientdata) {
23225 equiv = swig_module.types[i]->cast;
23226 while (equiv) {
23227 if (!equiv->converter) {
23228 if (equiv->type && !equiv->type->clientdata)
23230 }
23231 equiv = equiv->next;
23232 }
23233 }
23234 }
23235}
23236
23237#ifdef __cplusplus
23238#if 0
23239{
23240 /* c-mode */
23241#endif
23242}
23243#endif
23244
23245
23246
23247#ifdef __cplusplus
23248extern "C" {
23249#endif
23250
23251 /* -----------------------------------------------------------------------------
23252 * constants/methods manipulation
23253 * ----------------------------------------------------------------------------- */
23254
23255 /* Install Constants */
23256 SWIGINTERN void
23258 PyObject *obj = 0;
23259 size_t i;
23260 for (i = 0; constants[i].type; ++i) {
23261 switch(constants[i].type) {
23262 case SWIG_PY_POINTER:
23263 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23264 break;
23265 case SWIG_PY_BINARY:
23266 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23267 break;
23268 default:
23269 obj = 0;
23270 break;
23271 }
23272 if (obj) {
23273 PyDict_SetItemString(d, constants[i].name, obj);
23274 Py_DECREF(obj);
23275 }
23276 }
23277 }
23278
23279 /* -----------------------------------------------------------------------------
23280 * Patch %callback methods' docstrings to hold the callback ptrs
23281 * -----------------------------------------------------------------------------*/
23282
23283 SWIGINTERN void
23284 SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
23285 size_t i;
23286 for (i = 0; methods[i].ml_name; ++i) {
23287 const char *c = methods[i].ml_doc;
23288 if (!c) continue;
23289 c = strstr(c, "swig_ptr: ");
23290 if (c) {
23291 int j;
23292 const swig_const_info *ci = 0;
23293 const char *name = c + 10;
23294 for (j = 0; const_table[j].type; ++j) {
23295 if (strncmp(const_table[j].name, name,
23296 strlen(const_table[j].name)) == 0) {
23297 ci = &(const_table[j]);
23298 break;
23299 }
23300 }
23301 if (ci) {
23302 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23303 if (ptr) {
23304 size_t shift = (ci->ptype) - types;
23305 swig_type_info *ty = types_initial[shift];
23306 size_t ldoc = (c - methods[i].ml_doc);
23307 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23308 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23309 if (ndoc) {
23310 char *buff = ndoc;
23311 memcpy(buff, methods[i].ml_doc, ldoc);
23312 buff += ldoc;
23313 memcpy(buff, "swig_ptr: ", 10);
23314 buff += 10;
23315 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23316 methods[i].ml_doc = ndoc;
23317 }
23318 }
23319 }
23320 }
23321 }
23322 }
23323
23324#ifdef __cplusplus
23325}
23326#endif
23327
23328
23329
23330
23331/* -----------------------------------------------------------------------------*
23332 * Partial Init method
23333 * -----------------------------------------------------------------------------*/
23334
23335#ifdef __cplusplus
23336extern "C"
23337#endif
23338
23340#if PY_VERSION_HEX >= 0x03000000
23341PyObject*
23342#else
23343void
23344#endif
23346 PyObject *m, *d, *md, *globals;
23347
23348#if PY_VERSION_HEX >= 0x03000000
23349 static struct PyModuleDef SWIG_module = {
23350 PyModuleDef_HEAD_INIT,
23351 SWIG_name,
23352 NULL,
23353 -1,
23355 NULL,
23356 NULL,
23357 NULL,
23358 NULL
23359 };
23360#endif
23361
23362#if defined(SWIGPYTHON_BUILTIN)
23363 static SwigPyClientData SwigPyObject_clientdata = {
23364 0, 0, 0, 0, 0, 0, 0
23365 };
23366 static PyGetSetDef this_getset_def = {
23367 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23368 };
23369 static SwigPyGetSet thisown_getset_closure = {
23372 };
23373 static PyGetSetDef thisown_getset_def = {
23374 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23375 };
23376 PyTypeObject *builtin_pytype;
23377 int builtin_base_count;
23378 swig_type_info *builtin_basetype;
23379 PyObject *tuple;
23380 PyGetSetDescrObject *static_getset;
23381 PyTypeObject *metatype;
23382 PyTypeObject *swigpyobject;
23383 SwigPyClientData *cd;
23384 PyObject *public_interface, *public_symbol;
23385 PyObject *this_descr;
23386 PyObject *thisown_descr;
23387 PyObject *self = 0;
23388 int i;
23389
23390 (void)builtin_pytype;
23391 (void)builtin_base_count;
23392 (void)builtin_basetype;
23393 (void)tuple;
23394 (void)static_getset;
23395 (void)self;
23396
23397 /* Metaclass is used to implement static member variables */
23398 metatype = SwigPyObjectType();
23399 assert(metatype);
23400#endif
23401
23402 (void)globals;
23403
23404 /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
23405 SWIG_This();
23408#ifndef SWIGPYTHON_BUILTIN
23410#endif
23411
23412 /* Fix SwigMethods to carry the callback ptrs when needed */
23414
23415#if PY_VERSION_HEX >= 0x03000000
23416 m = PyModule_Create(&SWIG_module);
23417#else
23418 m = Py_InitModule(SWIG_name, SwigMethods);
23419#endif
23420
23421 md = d = PyModule_GetDict(m);
23422 (void)md;
23423
23425
23426#ifdef SWIGPYTHON_BUILTIN
23427 swigpyobject = SwigPyObject_TypeOnce();
23428
23429 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23430 assert(SwigPyObject_stype);
23431 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23432 if (!cd) {
23433 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23434 SwigPyObject_clientdata.pytype = swigpyobject;
23435 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
23436 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23437# if PY_VERSION_HEX >= 0x03000000
23438 return NULL;
23439# else
23440 return;
23441# endif
23442 }
23443
23444 /* All objects have a 'this' attribute */
23445 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23446 (void)this_descr;
23447
23448 /* All objects have a 'thisown' attribute */
23449 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23450 (void)thisown_descr;
23451
23452 public_interface = PyList_New(0);
23453 public_symbol = 0;
23454 (void)public_symbol;
23455
23456 PyDict_SetItemString(md, "__all__", public_interface);
23457 Py_DECREF(public_interface);
23458 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23459 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23460 for (i = 0; swig_const_table[i].name != 0; ++i)
23461 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23462#endif
23463
23465
23466
23467 import_array();
23468
23469 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23470 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23471 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23472 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23473 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23474 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23475 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23476 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23477 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23478 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23479 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23480 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23481 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23482 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23483 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23484 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23485 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23486 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23487 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23488 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23489 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23490 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23491 SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23492 SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23493 SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23494 SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23495 SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23496 SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23497 SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23498 SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23499 SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23500 SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23501 SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23502 SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23503 SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23504 SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23505 SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23506 SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23507 SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23508 SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23509 SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23510 SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23511 SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23512 SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23513 SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23514 SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23515 SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23516 SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23517 SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23518 SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23519 SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23520 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23521 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23522 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23523 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23524 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23525 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23526 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23527 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23528 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23529 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23530 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23531 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23532 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23533 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23534 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23535 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23536 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23537 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23538 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23539 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23540 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23541 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23542 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23543 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23544 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23545 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23546 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23547 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23548 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23549 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23550 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23551 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23552 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23553 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23554 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23555 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23556 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23557 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23558 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23559 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23560 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23561 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23562 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23563 SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23564 SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23565 SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23566 SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23567 SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23568 SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23569 SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23570 SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23571 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23572 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23573 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23574 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23575 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23576 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23577 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23578 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL0",SWIG_From_int((int)(16)));
23579 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL1",SWIG_From_int((int)(128)));
23580 SWIG_Python_SetConstant(d, "MIN_PLINT_RGB",SWIG_From_int((int)(0)));
23581 SWIG_Python_SetConstant(d, "MAX_PLINT_RGB",SWIG_From_int((int)(255)));
23582 SWIG_Python_SetConstant(d, "MIN_PLFLT_CMAP1",SWIG_From_double((double)(0.)));
23583 SWIG_Python_SetConstant(d, "MAX_PLFLT_CMAP1",SWIG_From_double((double)(1.)));
23584 SWIG_Python_SetConstant(d, "MIN_PLFLT_ALPHA",SWIG_From_double((double)(0.)));
23585 SWIG_Python_SetConstant(d, "MAX_PLFLT_ALPHA",SWIG_From_double((double)(1.)));
23586 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23587 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23588 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23589 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23590 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23591 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23592 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23593 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23594 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23595 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23596 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23597 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23598 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23599 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23600 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23601 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23602 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23603 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23604 SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23605 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23606 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23607 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23608 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23609 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23610 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23611 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23612 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23613 SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23614 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23615 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23616 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23617 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23618 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23619 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23620 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23621 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23622 SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23623 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23624 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23625 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23626 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23627 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23628 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23629 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23630 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23631 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23632 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23633 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23634 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23635 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23636 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23637 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23638 SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23639 SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23640 SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23641 SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23642 SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23643 SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23644 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23645 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23646 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23647 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23648 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23649 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23650 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23651 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23652 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23653 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23654#if PY_VERSION_HEX >= 0x03000000
23655 return m;
23656#else
23657 return;
23658#endif
23659}
23660
#define min(x, y)
Definition nnpi.c:87
#define max(x, y)
Definition nnpi.c:88
void plOptUsage(void)
Definition plargs.c:1304
void plClearOpts(void)
Definition plargs.c:830
void plResetOpts(void)
Definition plargs.c:843
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition plargs.c:1287
static int error
Definition plcont.c:61
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:941
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:874
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition plcont.c:858
void plsxwin(PLINT window_id)
Definition plcore.c:3978
static PLFLT value(double n1, double n2, double hue)
Definition plctrl.c:1219
void plMinMax2dGrid(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLFLT *fnmax, PLFLT *fnmin)
Definition plmem.c:141
PLINT plGetCursor(PLGraphicsIn *plg)
Definition plpage.c:244
#define plgfci
Definition plplot.h:735
#define plgstrm
Definition plplot.h:744
#define plpat
Definition plplot.h:779
#define plschr
Definition plplot.h:790
#define plfontld
Definition plplot.h:721
#define plpath
Definition plplot.h:761
#define plerry
Definition plplot.h:715
#define plsfam
Definition plplot.h:816
#define plsmaj
Definition plplot.h:826
#define plsmin
Definition plplot.h:829
#define pleop
Definition plplot.h:713
#define plimage
Definition plplot.h:753
#define plstransform
Definition plplot.h:840
#define plmap
Definition plplot.h:764
#define plfill
Definition plplot.h:717
#define plvpas
Definition plplot.h:859
#define plgdiplt
Definition plplot.h:732
#define plerrx
Definition plplot.h:714
#define plinit
Definition plplot.h:755
#define plscmap1l
Definition plplot.h:796
#define plsori
Definition plplot.h:830
#define plbox3
Definition plplot.h:698
#define plmapfill
Definition plplot.h:768
#define plcol1
Definition plplot.h:703
#define pltimefmt
Definition plplot.h:856
PLUINT PLUNICODE
Definition plplot.h:201
#define plmaptex
Definition plplot.h:767
#define plvect
Definition plplot.h:858
#define plgchr
Definition plplot.h:722
float PLFLT
Definition plplot.h:163
#define pllegend
Definition plplot.h:758
#define plsyax
Definition plplot.h:852
#define plgver
Definition plplot.h:745
#define plscolbg
Definition plplot.h:802
#define plpsty
Definition plplot.h:784
#define plgfont
Definition plplot.h:737
#define plenv
Definition plplot.h:711
#define pllightsource
Definition plplot.h:759
#define plsmema
Definition plplot.h:828
#define plpoin3
Definition plplot.h:781
#define plgspa
Definition plplot.h:743
#define plscol0
Definition plplot.h:800
#define plptex
Definition plplot.h:785
#define plrgbhls
Definition plplot.h:789
#define plbop
Definition plplot.h:696
#define plgdidev
Definition plplot.h:730
#define plpoin
Definition plplot.h:780
#define plptex3
Definition plplot.h:786
#define plstripd
Definition plplot.h:845
#define plhist
Definition plplot.h:751
#define plmapline
Definition plplot.h:765
#define plgfnam
Definition plplot.h:736
#define plgdiori
Definition plplot.h:731
#define plszax
Definition plplot.h:854
#define plsmem
Definition plplot.h:827
#define plstripa
Definition plplot.h:843
#define plgxax
Definition plplot.h:748
#define plgra
Definition plplot.h:740
#define plenv0
Definition plplot.h:712
#define plspal1
Definition plplot.h:833
#define plstring3
Definition plplot.h:842
#define plxormod
Definition plplot.h:865
#define plspause
Definition plplot.h:834
#define plgdev
Definition plplot.h:729
#define plgradient
Definition plplot.h:741
#define plspal0
Definition plplot.h:832
#define plcalc_world
Definition plplot.h:700
#define plwidth
Definition plplot.h:863
#define pllab
Definition plplot.h:757
#define plsurf3d
Definition plplot.h:847
#define plsurf3dl
Definition plplot.h:848
#define plvasp
Definition plplot.h:857
#define plscmap0n
Definition plplot.h:793
#define plmtex3
Definition plplot.h:774
#define plctime
Definition plplot.h:708
#define plclear
Definition plplot.h:701
#define plsvpa
Definition plplot.h:850
#define plw3d
Definition plplot.h:862
#define plot3dcl
Definition plplot.h:777
#define plscmap1n
Definition plplot.h:798
#define plgvpd
Definition plplot.h:746
#define plhlsrgb
Definition plplot.h:752
#define pl_setcontlabelformat
Definition plplot.h:690
#define plsdev
Definition plplot.h:806
#define plconfigtime
Definition plplot.h:705
#define plscolbga
Definition plplot.h:803
#define PL_UNUSED(x)
Definition plplot.h:138
#define plscmap1
Definition plplot.h:794
#define plsdiplz
Definition plplot.h:811
#define plparseopts
Definition plplot.h:778
#define plmapstring
Definition plplot.h:766
#define plot3d
Definition plplot.h:775
#define plsesc
Definition plplot.h:814
#define plarc
Definition plplot.h:693
#define plsetopt
Definition plplot.h:815
#define plgvpw
Definition plplot.h:747
#define pltext
Definition plplot.h:855
#define plstring
Definition plplot.h:841
#define plsdiori
Definition plplot.h:809
#define plcont
Definition plplot.h:706
#define plspage
Definition plplot.h:831
#define plaxes
Definition plplot.h:694
#define pllsty
Definition plplot.h:763
#define plslabelfunc
Definition plplot.h:825
#define plshades
Definition plplot.h:824
#define plglevel
Definition plplot.h:738
#define plscompression
Definition plplot.h:805
#define plfamadv
Definition plplot.h:716
#define plfont
Definition plplot.h:720
#define plscmap0a
Definition plplot.h:792
#define plgcol0a
Definition plplot.h:725
#define plscmap1_range
Definition plplot.h:799
#define plmeshc
Definition plplot.h:771
#define plshade
Definition plplot.h:820
#define plsym
Definition plplot.h:853
#define plscmap1a
Definition plplot.h:795
#define plscmap0
Definition plplot.h:791
#define plgriddata
Definition plplot.h:742
#define plstripc
Definition plplot.h:844
#define pl_setcontlabelparam
Definition plplot.h:691
#define plsvect
Definition plplot.h:849
#define plstyl
Definition plplot.h:846
#define plline
Definition plplot.h:760
#define pljoin
Definition plplot.h:756
#define plgzax
Definition plplot.h:750
#define plsstrm
Definition plplot.h:835
#define plscmap1la
Definition plplot.h:797
#define plssym
Definition plplot.h:837
#define plscolor
Definition plplot.h:804
#define plcol0
Definition plplot.h:702
#define plsdiplt
Definition plplot.h:810
#define plcolorbar
Definition plplot.h:704
#define plvsta
Definition plplot.h:861
#define plmeridians
Definition plplot.h:769
#define plot3dc
Definition plplot.h:776
#define plcpstrm
Definition plplot.h:707
#define plmkstrm
Definition plplot.h:772
#define plgcol0
Definition plplot.h:724
#define pladv
Definition plplot.h:692
#define plgcolbga
Definition plplot.h:727
#define plline3
Definition plplot.h:762
#define plprec
Definition plplot.h:783
#define plfill3
Definition plplot.h:718
#define plseed
Definition plplot.h:813
#define plgcompression
Definition plplot.h:728
#define plimagefr
Definition plplot.h:754
#define plsfont
Definition plplot.h:819
int PLINT
Definition plplot.h:181
#define plgfam
Definition plplot.h:734
#define plscol0a
Definition plplot.h:801
#define plend1
Definition plplot.h:710
#define plrandd
Definition plplot.h:787
#define plbin
Definition plplot.h:695
#define plsdidev
Definition plplot.h:807
#define plsfnam
Definition plplot.h:818
void * PLPointer
Definition plplot.h:209
#define plflush
Definition plplot.h:719
#define plwind
Definition plplot.h:864
#define plstar
Definition plplot.h:838
#define plmtex
Definition plplot.h:773
PLINT PLBOOL
Definition plplot.h:204
#define plsdimap
Definition plplot.h:808
#define plsfci
Definition plplot.h:817
#define plend
Definition plplot.h:709
#define plmesh
Definition plplot.h:770
#define plreplot
Definition plplot.h:788
#define plgcolbg
Definition plplot.h:726
#define plgcmap1_range
Definition plplot.h:723
#define plstart
Definition plplot.h:839
#define plsxax
Definition plplot.h:851
#define plbox
Definition plplot.h:697
#define plbtime
Definition plplot.h:699
#define plgyax
Definition plplot.h:749
#define plvpor
Definition plplot.h:860
#define plpoly3
Definition plplot.h:782
#define plgpage
Definition plplot.h:739
#define plssub
Definition plplot.h:836
SWIGINTERN PyObject * _wrap_plstransform(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *self, PyObject *args)
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *self, PyObject *args)
static swig_cast_info * swig_cast_initial[]
SWIGINTERN int swig_varlink_setattr(PyObject *o, char *n, PyObject *p)
SWIGINTERN PyObject * _wrap_plgra(PyObject *self, PyObject *args)
static int interpreter_counter
static PLcGrid2 tmpGrid2
SWIGINTERN PyObject * _wrap_plvpas(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *self, PyObject *args)
#define SWIG_MangledTypeQuery(name)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args)
static PLcGrid tmpGrid1
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *self, PyObject *args)
static PyObject * Swig_This_global
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
static swig_cast_info _swigc__p_PLcGrid2[]
SWIGINTERN PyObject * _wrap_plerrx(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *self, PyObject *args)
SWIGINTERN Py_ssize_t SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
#define SWIG_TypeQuery(name)
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *self, PyObject *args)
#define SWIG_POINTER_OWN
SWIGINTERN PyObject * _wrap_plfill3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args)
#define SWIG_SyntaxError
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *self, PyObject *args)
#define SWIG_POINTER_NEW
SWIGINTERN PyObject * _wrap_plgfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *self, PyObject *args)
#define SWIG_CheckState(r)
static swig_cast_info _swigc__p_f_double_double__int[]
void cleanup_mapform(void)
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_int[]
SWIGINTERN PyObject * _wrap_plschr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstart(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args)
#define SWIG_BUFFER_SIZE
#define SWIG_TypeError
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
pltr_func marshal_pltr(PyObject *input)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args)
static PLINT Alen
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args)
#define myArray_ContiguousFromObject
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plend(PyObject *self, PyObject *args)
#define SWIG_POINTER_IMPLICIT_CONV
static swig_cast_info _swigc__p_double[]
#define SWIGTYPE_p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *self, PyObject *args)
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plbin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *self, PyObject *args)
#define SWIG_PY_POINTER
struct swig_cast_info swig_cast_info
SWIGINTERN PyObject * _wrap_plpoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *self, PyObject *args)
#define SWIG_init
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
#define SWIG_PYTHON_THREAD_END_BLOCK
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *self, PyObject *args)
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *self, PyObject *args)
#define SWIG_RuntimeError
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
SWIGINTERN PyObject * _wrap_pladv(PyObject *self, PyObject *args)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *self, PyObject *args)
#define SWIGPY_CAPSULE_ATTR_NAME
SWIGINTERN PyObject * _wrap_plsfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmema(PyObject *self, PyObject *args)
struct swig_varlinkobject swig_varlinkobject
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *self, PyObject *args)
#define SWIG_NewClientData(obj)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *self, PyObject *args)
mapform_func marshal_mapform(PyObject *input)
#define PyObject_DEL
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGINTERN PyObject * _wrap_plline(PyObject *self, PyObject *args)
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *self, PyObject *args)
#define SWIGRUNTIME
SWIGINTERN PyObject * _wrap_plvasp(PyObject *self, PyObject *args)
#define SWIG_PY_BINARY
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *self, PyObject *args)
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *self, PyObject *args)
PyObject * python_f2eval
#define SWIG_RUNTIME_VERSION
SWIGINTERN PyObject * _wrap_plscolor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
SWIGINTERN PyObject * _wrap_plssym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *self, PyObject *args)
#define SWIG_POINTER_NOSHADOW
SWIGINTERN PyObject * _wrap_plwind(PyObject *self, PyObject *args)
#define SWIG_OLDOBJ
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
#define SWIG_ValueError
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGINTERN PyObject * _wrap_plend1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *self, PyObject *args)
static PyMethodDef swigobject_methods[]
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *self, PyObject *args)
#define SWIG_AddCast(r)
void cleanup_PLcGrid1(void)
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
#define SWIG_IsNewObj(r)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *self, PyObject *args)
#define SWIG_InternalNewPointerObj(ptr, type, flags)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *self, PyObject *args)
#define NPY_PLFLT
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
#define SWIG_exception_fail(code, msg)
void cleanup_ct(void)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltr2(PyObject *self, PyObject *args)
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args)
#define SWIG_AttributeError
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args)
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args)
static swig_module_info swig_module
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *self, PyObject *args)
static PLINT Ylen
SWIGINTERN PyObject * _wrap_pltr1(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_double
SWIGINTERN PyObject * _wrap_plgdev(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_TypeErrorOccurred(PyObject *obj)
SWIGRUNTIME void SWIG_Python_DestroyModule(PyObject *obj)
#define SWIG_SetModule(clientdata, pointer)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *self, PyObject *args)
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
SWIGINTERN PyObject * swig_varlink_str(PyObject *o)
SWIGINTERN PyTypeObject * swig_varlink_type(void)
SWIGINTERN PyObject * _wrap_pllab(PyObject *self, PyObject *args)
#define SWIG_INIT_CLIENT_DATA_TYPE
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *self, PyObject *args)
#define SWIGUNUSEDPARM(p)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *self, PyObject *args)
PLPointer marshal_PLPointer(PyObject *input, int isimg)
#define SWIG_POINTER_RELEASE
SWIGINTERN PyObject * _wrap_plstring3(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define SWIG_as_voidptr(a)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
static swig_const_info swig_const_table[]
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plscol0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
static swig_type_info _swigt__p_p_char
#define SWIG_Python_CallFunctor(functor, obj)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
static swig_type_info _swigt__p_p_double
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *self, PyObject *args)
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
#define SWIG_POINTER_CLEAR
PyObject * python_label
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
#define SWIGTYPE_p_int
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
struct swig_const_info swig_const_info
SWIGINTERN PyObject * _wrap_plpsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plimage(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *self, PyObject *args)
static PyObject * Swig_Globals_global
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *self, PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *self, PyObject *args)
#define SWIG_newvarlink()
SWIGRUNTIME void SWIG_Python_RaiseOrModifyTypeError(const char *message)
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
SWIGINTERN const char * SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
PLINT(* defined_func)(PLFLT, PLFLT)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *self, PyObject *args)
void cleanup_pltr(void)
void cleanup_PLcGrid2(void)
static PyObject * Swig_TypeCache_global
SWIGINTERN PyObject * _wrap_plglevel(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_p_double[]
#define SWIGINTERN
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
SWIGINTERN PyObject * _wrap_plpath(PyObject *self, PyObject *args)
#define SWIG_From_double
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
struct swig_globalvar swig_globalvar
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
#define SWIGPY_CAPSULE_NAME
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
#define SWIG_ArgError(r)
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
PyObject * python_pltr
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
#define SWIG_NewPointerObj(ptr, type, flags)
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *self, PyObject *args)
ct_func marshal_ct(PyObject *input)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *self, PyObject *args)
#define SWIG_POINTER_NO_NULL
#define SWIG_Python_str_FromFormat
#define SWIG_InstallConstants(d, constants)
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *self, PyObject *args)
#define SWIG_IOError
static PyMethodDef SwigMethods[]
#define SWIG_NullReferenceError
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_pleop(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
#define SWIG_POINTER_DISOWN
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args)
#define SWIG_STATIC_POINTER(var)
struct swig_type_info swig_type_info
PyObject * python_mapform
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v))
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
static swig_type_info _swigt__p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plflush(PyObject *self, PyObject *args)
#define SWIG_IsTmpObj(r)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_f_double_double__int
SWIGINTERN PyObject * _wrap_plcont(PyObject *self, PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
SWIGINTERN PyObject * _wrap_plsori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plbop(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
#define SWIG_NEWOBJ
#define MY_BLOCK_THREADS
SWIGINTERN PyObject * _wrap_plgver(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *self, PyObject *args)
#define SWIG_TMPOBJ
SWIGINTERN PyObject * _wrap_pllsty(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
#define SWIG_DelNewMask(r)
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *self, PyObject *args)
#define SWIG_NewPackedObj(ptr, sz, type)
static swig_cast_info _swigc__p_PLcGrid[]
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *self, PyObject *args)
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
#define SWIG_GetModule(clientdata)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_unsigned_int[]
#define SWIG_fail
static swig_type_info _swigt__p_int
SWIGINTERN PyObject * PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *self, PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty)
SWIGRUNTIME void SWIG_PropagateClientData(void)
PyArrayObject * pltr_xg
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
#define NPY_PLINT
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
SWIGINTERN PyObject * _wrap_plsmem(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *self, PyObject *args)
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
#define SWIG_ERROR_RELEASE_NOT_OWNED
SWIGRUNTIME PyObject * SWIG_This(void)
SWIGINTERN PyObject * _wrap_plenv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_PLcGrid
#define SWIG_BUILTIN_TP_INIT
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
SWIGINTERN void swig_varlink_dealloc(PyObject *o)
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v)
static PLINT Xlen
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
SWIGINTERN PyObject * _wrap_plfont(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *self, PyObject *args)
PyArrayObject * pltr_yg
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args)
struct swig_module_info swig_module_info
PyObject * python_ct
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
#define SWIG_ERROR
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
#define SWIG_name
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *self, PyObject *args)
static swig_type_info * swig_type_initial[]
SWIGINTERN PyObject * _wrap_plerry(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *self, PyObject *args)
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
#define PySequence_Fast_GET_ITEM
SWIGINTERN PyObject * _wrap_plmap(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
SWIGINTERN PyObject * _wrap_plhist(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGINTERN PyObject * _wrap_pltr0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *self, PyObject *args)
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_getattr(PyObject *o, char *n)
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args)
#define PySequence_Size
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *self, PyObject *args)
#define SWIG_MemoryError
SWIGINTERN PyObject * _wrap_plfontld(PyObject *self, PyObject *args)
#define SWIG_SystemError
#define SWIG_DivisionByZero
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args)
#define SWIGTYPE_p_double
static swig_type_info _swigt__p_char
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
#define SWIG_OverflowError
#define SWIGEXPORT
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
#define SWIG_IsOK(r)
SWIGINTERN PyObject * _wrap_plstring(PyObject *self, PyObject *args)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
static PyObject * Swig_Capsule_global
static swig_type_info _swigt__p_PLcGrid2
SWIGINTERN PyObject * _wrap_plctime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *self, PyObject *args)
#define SWIG_IndexError
SWIGINTERN PyObject * _wrap_plspal0(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
static swig_type_info * swig_types[15]
SWIGRUNTIME PyObject * SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *self, PyObject *args)
#define SWIG_AddNewMask(r)
SWIGINTERN PyObject * SWIG_globals(void)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *self, PyObject *args)
#define SWIG_OK
SWIGINTERN PyObject * _wrap_plbox(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args)
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#define SWIGINTERNINLINE
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *self, PyObject *args)
enum callback_type pltr_type
SWIGINTERN PyObject * _wrap_plaxes(PyObject *self, PyObject *args)
#define Py_TYPE(op)
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
#define MY_UNBLOCK_THREADS
#define SWIGRUNTIMEINLINE
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
char string[PL_MAXKEY]
Definition plplot.h:440
PLINT nx
Definition plplot.h:521
PLFLT_NC_MATRIX xg
Definition plplot.h:520
PLINT ny
Definition plplot.h:521
PLFLT_NC_MATRIX yg
Definition plplot.h:520
PLFLT_NC_FE_POINTER xg
Definition plplot.h:508
PLFLT_NC_FE_POINTER yg
Definition plplot.h:508
PLINT nx
Definition plplot.h:509
PLINT ny
Definition plplot.h:509
PyObject_HEAD void * ptr
swig_type_info * ty
swig_type_info * ty
PyObject_HEAD void * pack
swig_type_info * type
struct swig_cast_info * prev
struct swig_cast_info * next
swig_converter_func converter
swig_type_info ** ptype
PyObject *(* get_attr)(void)
struct swig_globalvar * next
int(* set_attr)(PyObject *)
swig_type_info ** types
swig_cast_info ** cast_initial
swig_type_info ** type_initial
struct swig_module_info * next
swig_dycast_func dcast
struct swig_cast_info * cast
PyObject_HEAD swig_globalvar * vars
static char buf[200]
Definition tclAPI.c:873
static tclMatrixXtnsnDescr * tail
Definition tclMatrix.c:461
static const char * name
Definition tkMain.c:135