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 pyobj = PyWeakref_GET_OBJECT(pyobj);
2453 if (pyobj && SwigPyObject_Check(pyobj))
2454 return (SwigPyObject*) pyobj;
2455 }
2456# endif
2457 return NULL;
2458#else
2459
2460 obj = 0;
2461
2462#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2463 if (PyInstance_Check(pyobj)) {
2464 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2465 } else {
2466 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2467 if (dictptr != NULL) {
2468 PyObject *dict = *dictptr;
2469 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2470 } else {
2471#ifdef PyWeakref_CheckProxy
2472 if (PyWeakref_CheckProxy(pyobj)) {
2473 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2474 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2475 }
2476#endif
2477 obj = PyObject_GetAttr(pyobj,SWIG_This());
2478 if (obj) {
2479 Py_DECREF(obj);
2480 } else {
2481 if (PyErr_Occurred()) PyErr_Clear();
2482 return 0;
2483 }
2484 }
2485 }
2486#else
2487 obj = PyObject_GetAttr(pyobj,SWIG_This());
2488 if (obj) {
2489 Py_DECREF(obj);
2490 } else {
2491 if (PyErr_Occurred()) PyErr_Clear();
2492 return 0;
2493 }
2494#endif
2495 if (obj && !SwigPyObject_Check(obj)) {
2496 /* a PyObject is called 'this', try to get the 'real this'
2497 SwigPyObject from it */
2498 return SWIG_Python_GetSwigThis(obj);
2499 }
2500 return (SwigPyObject *)obj;
2501#endif
2502}
2503
2504/* Acquire a pointer value */
2505
2506SWIGRUNTIME int
2507SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2508 if (own == SWIG_POINTER_OWN) {
2510 if (sobj) {
2511 int oldown = sobj->own;
2512 sobj->own = own;
2513 return oldown;
2514 }
2515 }
2516 return 0;
2517}
2518
2519/* Convert a pointer value */
2520
2521SWIGRUNTIME int
2522SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2523 int res;
2524 SwigPyObject *sobj;
2525 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2526
2527 if (!obj)
2528 return SWIG_ERROR;
2529 if (obj == Py_None && !implicit_conv) {
2530 if (ptr)
2531 *ptr = 0;
2533 }
2534
2535 res = SWIG_ERROR;
2536
2537 sobj = SWIG_Python_GetSwigThis(obj);
2538 if (own)
2539 *own = 0;
2540 while (sobj) {
2541 void *vptr = sobj->ptr;
2542 if (ty) {
2543 swig_type_info *to = sobj->ty;
2544 if (to == ty) {
2545 /* no type cast needed */
2546 if (ptr) *ptr = vptr;
2547 break;
2548 } else {
2549 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2550 if (!tc) {
2551 sobj = (SwigPyObject *)sobj->next;
2552 } else {
2553 if (ptr) {
2554 int newmemory = 0;
2555 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2556 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2557 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2558 if (own)
2559 *own = *own | SWIG_CAST_NEW_MEMORY;
2560 }
2561 }
2562 break;
2563 }
2564 }
2565 } else {
2566 if (ptr) *ptr = vptr;
2567 break;
2568 }
2569 }
2570 if (sobj) {
2571 if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
2573 } else {
2574 if (own)
2575 *own = *own | sobj->own;
2576 if (flags & SWIG_POINTER_DISOWN) {
2577 sobj->own = 0;
2578 }
2579 if (flags & SWIG_POINTER_CLEAR) {
2580 sobj->ptr = 0;
2581 }
2582 res = SWIG_OK;
2583 }
2584 } else {
2585 if (implicit_conv) {
2586 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2587 if (data && !data->implicitconv) {
2588 PyObject *klass = data->klass;
2589 if (klass) {
2590 PyObject *impconv;
2591 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2592 impconv = SWIG_Python_CallFunctor(klass, obj);
2593 data->implicitconv = 0;
2594 if (PyErr_Occurred()) {
2595 PyErr_Clear();
2596 impconv = 0;
2597 }
2598 if (impconv) {
2599 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2600 if (iobj) {
2601 void *vptr;
2602 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2603 if (SWIG_IsOK(res)) {
2604 if (ptr) {
2605 *ptr = vptr;
2606 /* transfer the ownership to 'ptr' */
2607 iobj->own = 0;
2608 res = SWIG_AddCast(res);
2609 res = SWIG_AddNewMask(res);
2610 } else {
2611 res = SWIG_AddCast(res);
2612 }
2613 }
2614 }
2615 Py_DECREF(impconv);
2616 }
2617 }
2618 }
2619 if (!SWIG_IsOK(res) && obj == Py_None) {
2620 if (ptr)
2621 *ptr = 0;
2622 if (PyErr_Occurred())
2623 PyErr_Clear();
2624 res = SWIG_OK;
2625 }
2626 }
2627 }
2628 return res;
2629}
2630
2631/* Convert a function ptr value */
2632
2633SWIGRUNTIME int
2634SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2635 if (!PyCFunction_Check(obj)) {
2636 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2637 } else {
2638 void *vptr = 0;
2639 swig_cast_info *tc;
2640
2641 /* here we get the method pointer for callbacks */
2642#ifndef Py_LIMITED_API
2643 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2644#else
2645 PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
2646 PyObject *bytes = NULL;
2647 const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
2648#endif
2649 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2650 if (desc)
2651 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2652#ifdef Py_LIMITED_API
2653 Py_XDECREF(bytes);
2654 Py_XDECREF(pystr_doc);
2655#endif
2656 if (!desc)
2657 return SWIG_ERROR;
2658 tc = SWIG_TypeCheck(desc,ty);
2659 if (tc) {
2660 int newmemory = 0;
2661 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2662 assert(!newmemory); /* newmemory handling not yet implemented */
2663 } else {
2664 return SWIG_ERROR;
2665 }
2666 return SWIG_OK;
2667 }
2668}
2669
2670/* Convert a packed pointer value */
2671
2672SWIGRUNTIME int
2673SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2674 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2675 if (!to) return SWIG_ERROR;
2676 if (ty) {
2677 if (to != ty) {
2678 /* check type cast? */
2679 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2680 if (!tc) return SWIG_ERROR;
2681 }
2682 }
2683 return SWIG_OK;
2684}
2685
2686/* -----------------------------------------------------------------------------
2687 * Create a new pointer object
2688 * ----------------------------------------------------------------------------- */
2689
2690/*
2691 Create a new instance object, without calling __init__, and set the
2692 'this' attribute.
2693*/
2694
2695SWIGRUNTIME PyObject*
2697{
2698 PyObject *inst = 0;
2699 PyObject *newraw = data->newraw;
2700 if (newraw) {
2701 inst = PyObject_Call(newraw, data->newargs, NULL);
2702 if (inst) {
2703#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2704 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2705 if (dictptr != NULL) {
2706 PyObject *dict = *dictptr;
2707 if (dict == NULL) {
2708 dict = PyDict_New();
2709 *dictptr = dict;
2710 }
2711 if (dict) {
2712 PyDict_SetItem(dict, SWIG_This(), swig_this);
2713 } else{
2714 Py_DECREF(inst);
2715 inst = 0;
2716 }
2717 }
2718#else
2719 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2720 Py_DECREF(inst);
2721 inst = 0;
2722 }
2723#endif
2724 }
2725 } else {
2726#if PY_VERSION_HEX >= 0x03000000
2727 PyObject *empty_args = PyTuple_New(0);
2728 if (empty_args) {
2729 PyObject *empty_kwargs = PyDict_New();
2730 if (empty_kwargs) {
2731#ifndef Py_LIMITED_API
2732 newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
2733#else
2734 newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
2735#endif
2736 inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
2737 Py_DECREF(empty_kwargs);
2738 if (inst) {
2739 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2740 Py_DECREF(inst);
2741 inst = 0;
2742 } else {
2743 PyType_Modified(Py_TYPE(inst));
2744 }
2745 }
2746 }
2747 Py_DECREF(empty_args);
2748 }
2749#else
2750 PyObject *dict = PyDict_New();
2751 if (dict) {
2752 PyDict_SetItem(dict, SWIG_This(), swig_this);
2753 inst = PyInstance_NewRaw(data->newargs, dict);
2754 Py_DECREF(dict);
2755 }
2756#endif
2757 }
2758 return inst;
2759}
2760
2761SWIGRUNTIME int
2762SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2763{
2764#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2765 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2766 if (dictptr != NULL) {
2767 PyObject *dict = *dictptr;
2768 if (dict == NULL) {
2769 dict = PyDict_New();
2770 *dictptr = dict;
2771 }
2772 if (dict) {
2773 return PyDict_SetItem(dict, SWIG_This(), swig_this);
2774 } else{
2775 return -1;
2776 }
2777 }
2778#endif
2779 return PyObject_SetAttr(inst, SWIG_This(), swig_this);
2780}
2781
2782
2783SWIGINTERN PyObject *
2785 PyObject *obj[2];
2786 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2787 return NULL;
2788 } else {
2789 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2790 if (sthis) {
2791 Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
2792 } else {
2793 if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
2794 return NULL;
2795 }
2796 return SWIG_Py_Void();
2797 }
2798}
2799
2800/* Create a new pointer object */
2801
2802SWIGRUNTIME PyObject *
2803SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2804 SwigPyClientData *clientdata;
2805 PyObject * robj;
2806 int own;
2807
2808 if (!ptr)
2809 return SWIG_Py_Void();
2810
2811 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2812 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2813 if (clientdata && clientdata->pytype) {
2814 SwigPyObject *newobj;
2815 if (flags & SWIG_BUILTIN_TP_INIT) {
2816 newobj = (SwigPyObject*) self;
2817 if (newobj->ptr) {
2818#ifndef Py_LIMITED_API
2819 allocfunc alloc = clientdata->pytype->tp_alloc;
2820#else
2821 allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
2822#endif
2823 PyObject *next_self = alloc(clientdata->pytype, 0);
2824 while (newobj->next)
2825 newobj = (SwigPyObject *) newobj->next;
2826 newobj->next = next_self;
2827 newobj = (SwigPyObject *)next_self;
2828#ifdef SWIGPYTHON_BUILTIN
2829 newobj->dict = 0;
2830#endif
2831 }
2832 } else {
2833 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2834#ifdef SWIGPYTHON_BUILTIN
2835 if (newobj) {
2836 newobj->dict = 0;
2837 }
2838#endif
2839 }
2840 if (newobj) {
2841 newobj->ptr = ptr;
2842 newobj->ty = type;
2843 newobj->own = own;
2844 newobj->next = 0;
2845 return (PyObject*) newobj;
2846 }
2847 return SWIG_Py_Void();
2848 }
2849
2850 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2851
2852 robj = SwigPyObject_New(ptr, type, own);
2853 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2854 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2855 Py_DECREF(robj);
2856 robj = inst;
2857 }
2858 return robj;
2859}
2860
2861/* Create a new packed object */
2862
2863SWIGRUNTIMEINLINE PyObject *
2864SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2865 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2866}
2867
2868/* -----------------------------------------------------------------------------*
2869 * Get type list
2870 * -----------------------------------------------------------------------------*/
2871
2872#ifdef SWIG_LINK_RUNTIME
2873void *SWIG_ReturnGlobalTypeList(void *);
2874#endif
2875
2876static PyObject *Swig_TypeCache_global = NULL;
2877
2878/* The python cached type query */
2879SWIGRUNTIME PyObject *
2881 if (Swig_TypeCache_global == NULL) {
2882 Swig_TypeCache_global = PyDict_New();
2883 }
2884 return Swig_TypeCache_global;
2885}
2886
2889#ifdef SWIG_LINK_RUNTIME
2890 static void *type_pointer = (void *)0;
2891 /* first check if module already created */
2892 if (!type_pointer) {
2893 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2894 }
2895#else
2896 void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2897 if (PyErr_Occurred()) {
2898 PyErr_Clear();
2899 type_pointer = (void *)0;
2900 }
2901#endif
2902 return (swig_module_info *) type_pointer;
2903}
2904
2905
2906static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */
2907
2908SWIGRUNTIME void
2910{
2911 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2912 swig_type_info **types = swig_module->types;
2913 size_t i;
2914 if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
2915 return;
2916 for (i =0; i < swig_module->size; ++i) {
2917 swig_type_info *ty = types[i];
2918 if (ty->owndata) {
2920 ty->clientdata = 0;
2921 if (data) SwigPyClientData_Del(data);
2922 }
2923 }
2924 Py_DECREF(SWIG_This());
2925 Swig_This_global = NULL;
2926 Py_DECREF(SWIG_globals());
2927 Swig_Globals_global = NULL;
2928 Py_DECREF(SWIG_Python_TypeCache());
2929 Swig_TypeCache_global = NULL;
2930 Swig_Capsule_global = NULL;
2931}
2932
2933SWIGRUNTIME void
2935#if PY_VERSION_HEX >= 0x03000000
2936 /* Add a dummy module object into sys.modules */
2937 PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2938#else
2939 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2940 PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2941#endif
2942 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2943 if (pointer && module) {
2944 if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
2946 Swig_Capsule_global = pointer;
2947 } else {
2948 Py_DECREF(pointer);
2949 }
2950 } else {
2951 Py_XDECREF(pointer);
2952 }
2953}
2954
2956SWIG_Python_TypeQuery(const char *type)
2957{
2958 PyObject *cache = SWIG_Python_TypeCache();
2959 PyObject *key = SWIG_Python_str_FromChar(type);
2960 PyObject *obj = PyDict_GetItem(cache, key);
2961 swig_type_info *descriptor;
2962 if (obj) {
2963 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2964 } else {
2966 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2967 if (descriptor) {
2968 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2969 if (obj) {
2970 PyDict_SetItem(cache, key, obj);
2971 Py_DECREF(obj);
2972 }
2973 }
2974 }
2975 Py_DECREF(key);
2976 return descriptor;
2977}
2978
2979/*
2980 For backward compatibility only
2981*/
2982#define SWIG_POINTER_EXCEPTION 0
2983#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2984#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2985
2986SWIGRUNTIME int
2987SWIG_Python_AddErrMesg(const char* mesg, int infront)
2988{
2989 if (PyErr_Occurred()) {
2990 PyObject *type = 0;
2991 PyObject *value = 0;
2992 PyObject *traceback = 0;
2993 PyErr_Fetch(&type, &value, &traceback);
2994 if (value) {
2995 PyObject *old_str = PyObject_Str(value);
2996 PyObject *bytes = NULL;
2997 const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
2998 const char *errmesg = tmp ? tmp : "Invalid error message";
2999 Py_XINCREF(type);
3000 PyErr_Clear();
3001 if (infront) {
3002 PyErr_Format(type, "%s %s", mesg, errmesg);
3003 } else {
3004 PyErr_Format(type, "%s %s", errmesg, mesg);
3005 }
3006 Py_XDECREF(bytes);
3007 Py_DECREF(old_str);
3008 }
3009 return 1;
3010 } else {
3011 return 0;
3012 }
3013}
3014
3015SWIGRUNTIME int
3017{
3018 if (PyErr_Occurred()) {
3019 /* add information about failing argument */
3020 char mesg[256];
3021 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
3022 return SWIG_Python_AddErrMesg(mesg, 1);
3023 } else {
3024 return 0;
3025 }
3026}
3027
3028SWIGRUNTIMEINLINE const char *
3030{
3031 SwigPyObject *v = (SwigPyObject *)self;
3032 swig_type_info *ty = v ? v->ty : 0;
3033 return ty ? ty->str : "";
3034}
3035
3036SWIGRUNTIME void
3037SWIG_Python_TypeError(const char *type, PyObject *obj)
3038{
3039 if (type) {
3040#if defined(SWIG_COBJECT_TYPES)
3041 if (obj && SwigPyObject_Check(obj)) {
3042 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
3043 if (otype) {
3044 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
3045 type, otype);
3046 return;
3047 }
3048 } else
3049#endif
3050 {
3051#ifndef Py_LIMITED_API
3052 /* tp_name is not accessible */
3053 const char *otype = (obj ? obj->ob_type->tp_name : 0);
3054 if (otype) {
3055 PyObject *str = PyObject_Str(obj);
3056 PyObject *bytes = NULL;
3057 const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0;
3058 if (cstr) {
3059 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
3060 type, otype, cstr);
3061 } else {
3062 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
3063 type, otype);
3064 }
3065 Py_XDECREF(bytes);
3066 Py_XDECREF(str);
3067 return;
3068 }
3069#endif
3070 }
3071 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
3072 } else {
3073 PyErr_Format(PyExc_TypeError, "unexpected type is received");
3074 }
3075}
3076
3077
3078/* Convert a pointer value, signal an exception on a type mismatch */
3079SWIGRUNTIME void *
3080SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
3081 void *result;
3082 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
3083 PyErr_Clear();
3084 }
3085 return result;
3086}
3087
3088#ifdef SWIGPYTHON_BUILTIN
3089SWIGRUNTIME int
3090SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
3091 PyTypeObject *tp = obj->ob_type;
3092 PyObject *descr;
3093 PyObject *encoded_name;
3094 descrsetfunc f;
3095 int res = -1;
3096
3097# ifdef Py_USING_UNICODE
3098 if (PyString_Check(name)) {
3099 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
3100 if (!name)
3101 return -1;
3102 } else if (!PyUnicode_Check(name))
3103# else
3104 if (!PyString_Check(name))
3105# endif
3106 {
3107 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
3108 return -1;
3109 } else {
3110 Py_INCREF(name);
3111 }
3112
3113 if (!tp->tp_dict) {
3114 if (PyType_Ready(tp) != 0)
3115 goto done;
3116 }
3117
3118 descr = _PyType_Lookup(tp, name);
3119 f = NULL;
3120 if (descr != NULL)
3121 f = descr->ob_type->tp_descr_set;
3122 if (!f) {
3123 if (PyString_Check(name)) {
3124 encoded_name = name;
3125 Py_INCREF(name);
3126 } else {
3127 encoded_name = PyUnicode_AsUTF8String(name);
3128 if (!encoded_name)
3129 goto done;
3130 }
3131 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
3132 Py_DECREF(encoded_name);
3133 } else {
3134 res = f(descr, obj, value);
3135 }
3136
3137 done:
3138 Py_DECREF(name);
3139 return res;
3140}
3141#endif
3142
3143
3144#ifdef __cplusplus
3145}
3146#endif
3147
3148
3149
3150#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3151
3152#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
3153
3154
3155
3156/* -------- TYPES TABLE (BEGIN) -------- */
3157
3158#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
3159#define SWIGTYPE_p_PLcGrid swig_types[1]
3160#define SWIGTYPE_p_PLcGrid2 swig_types[2]
3161#define SWIGTYPE_p_char swig_types[3]
3162#define SWIGTYPE_p_double swig_types[4]
3163#define SWIGTYPE_p_f_double_double__int swig_types[5]
3164#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
3165#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
3166#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
3167#define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
3168#define SWIGTYPE_p_int swig_types[10]
3169#define SWIGTYPE_p_p_char swig_types[11]
3170#define SWIGTYPE_p_p_double swig_types[12]
3171#define SWIGTYPE_p_unsigned_int swig_types[13]
3173static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
3174#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3175#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3176
3177/* -------- TYPES TABLE (END) -------- */
3178
3179#ifdef SWIG_TypeQuery
3180# undef SWIG_TypeQuery
3181#endif
3182#define SWIG_TypeQuery SWIG_Python_TypeQuery
3183
3184/*-----------------------------------------------
3185 @(target):= _plplotc.so
3186 ------------------------------------------------*/
3187#if PY_VERSION_HEX >= 0x03000000
3188# define SWIG_init PyInit__plplotc
3189
3190#else
3191# define SWIG_init init_plplotc
3192
3193#endif
3194#define SWIG_name "_plplotc"
3195
3196#define SWIG_as_voidptr(a) (void *)((const void *)(a))
3197#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3198
3199
3200#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
3201#include <arrayobject.h>
3202#include "plplot.h"
3203#include "plplotP.h"
3204
3205#define NPY_PLINT NPY_INT32
3206
3207#ifdef PL_DOUBLE
3208#define NPY_PLFLT NPY_FLOAT64
3209#else
3210#define NPY_PLFLT NPY_FLOAT32
3211#endif
3212
3213// python-1.5 compatibility mode?
3214#if !defined ( PySequence_Fast_GET_ITEM )
3215 #define PySequence_Fast_GET_ITEM PySequence_GetItem
3216#endif
3217#define PySequence_Size PySequence_Length
3218
3219
3220 static PLINT Alen = 0;
3221 static PLINT Xlen = 0, Ylen = 0;
3222
3223
3224SWIGINTERN int
3225SWIG_AsVal_double (PyObject *obj, double *val)
3226{
3227 int res = SWIG_TypeError;
3228 if (PyFloat_Check(obj)) {
3229 if (val) *val = PyFloat_AsDouble(obj);
3230 return SWIG_OK;
3231#if PY_VERSION_HEX < 0x03000000
3232 } else if (PyInt_Check(obj)) {
3233 if (val) *val = (double) PyInt_AsLong(obj);
3234 return SWIG_OK;
3235#endif
3236 } else if (PyLong_Check(obj)) {
3237 double v = PyLong_AsDouble(obj);
3238 if (!PyErr_Occurred()) {
3239 if (val) *val = v;
3240 return SWIG_OK;
3241 } else {
3242 PyErr_Clear();
3243 }
3244 }
3245#ifdef SWIG_PYTHON_CAST_MODE
3246 {
3247 int dispatch = 0;
3248 double d = PyFloat_AsDouble(obj);
3249 if (!PyErr_Occurred()) {
3250 if (val) *val = d;
3251 return SWIG_AddCast(SWIG_OK);
3252 } else {
3253 PyErr_Clear();
3254 }
3255 if (!dispatch) {
3256 long v = PyLong_AsLong(obj);
3257 if (!PyErr_Occurred()) {
3258 if (val) *val = v;
3260 } else {
3261 PyErr_Clear();
3262 }
3263 }
3264 }
3265#endif
3266 return res;
3267}
3268
3269
3270 #define SWIG_From_double PyFloat_FromDouble
3271
3272
3273 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3274 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3275 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3276 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3277 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3279 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3280
3281
3282SWIGINTERNINLINE PyObject*
3284{
3285 return PyInt_FromLong((long) value);
3286}
3287
3288
3289#include <limits.h>
3290#if !defined(SWIG_NO_LLONG_MAX)
3291# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3292# define LLONG_MAX __LONG_LONG_MAX__
3293# define LLONG_MIN (-LLONG_MAX - 1LL)
3294# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3295# endif
3296#endif
3297
3298
3299#include <float.h>
3300
3301
3302#include <math.h>
3303
3304
3306SWIG_CanCastAsInteger(double *d, double min, double max) {
3307 double x = *d;
3308 if ((min <= x && x <= max)) {
3309 double fx, cx, rd;
3310 errno = 0;
3311 fx = floor(x);
3312 cx = ceil(x);
3313 rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3314 if ((errno == EDOM) || (errno == ERANGE)) {
3315 errno = 0;
3316 } else {
3317 double summ, reps, diff;
3318 if (rd < x) {
3319 diff = x - rd;
3320 } else if (rd > x) {
3321 diff = rd - x;
3322 } else {
3323 return 1;
3324 }
3325 summ = rd + x;
3326 reps = diff/summ;
3327 if (reps < 8*DBL_EPSILON) {
3328 *d = rd;
3329 return 1;
3330 }
3331 }
3332 }
3333 return 0;
3334}
3335
3336
3337SWIGINTERN int
3338SWIG_AsVal_long (PyObject *obj, long* val)
3339{
3340#if PY_VERSION_HEX < 0x03000000
3341 if (PyInt_Check(obj)) {
3342 if (val) *val = PyInt_AsLong(obj);
3343 return SWIG_OK;
3344 } else
3345#endif
3346 if (PyLong_Check(obj)) {
3347 long v = PyLong_AsLong(obj);
3348 if (!PyErr_Occurred()) {
3349 if (val) *val = v;
3350 return SWIG_OK;
3351 } else {
3352 PyErr_Clear();
3353 return SWIG_OverflowError;
3354 }
3355 }
3356#ifdef SWIG_PYTHON_CAST_MODE
3357 {
3358 int dispatch = 0;
3359 long v = PyInt_AsLong(obj);
3360 if (!PyErr_Occurred()) {
3361 if (val) *val = v;
3362 return SWIG_AddCast(SWIG_OK);
3363 } else {
3364 PyErr_Clear();
3365 }
3366 if (!dispatch) {
3367 double d;
3368 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3369 // Largest double not larger than LONG_MAX (not portably calculated easily)
3370 // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
3371 // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
3372 const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
3373 // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
3374 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
3375 if (val) *val = (long)(d);
3376 return res;
3377 }
3378 }
3379 }
3380#endif
3381 return SWIG_TypeError;
3382}
3383
3384
3385SWIGINTERN int
3386SWIG_AsVal_int (PyObject * obj, int *val)
3387{
3388 long v;
3389 int res = SWIG_AsVal_long (obj, &v);
3390 if (SWIG_IsOK(res)) {
3391 if ((v < INT_MIN || v > INT_MAX)) {
3392 return SWIG_OverflowError;
3393 } else {
3394 if (val) *val = (int)(v);
3395 }
3396 }
3397 return res;
3398}
3399
3400
3401SWIGINTERN int
3402SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3403{
3404#if PY_VERSION_HEX < 0x03000000
3405 if (PyInt_Check(obj)) {
3406 long v = PyInt_AsLong(obj);
3407 if (v >= 0) {
3408 if (val) *val = v;
3409 return SWIG_OK;
3410 } else {
3411 return SWIG_OverflowError;
3412 }
3413 } else
3414#endif
3415 if (PyLong_Check(obj)) {
3416 unsigned long v = PyLong_AsUnsignedLong(obj);
3417 if (!PyErr_Occurred()) {
3418 if (val) *val = v;
3419 return SWIG_OK;
3420 } else {
3421 PyErr_Clear();
3422 return SWIG_OverflowError;
3423 }
3424 }
3425#ifdef SWIG_PYTHON_CAST_MODE
3426 {
3427 int dispatch = 0;
3428 unsigned long v = PyLong_AsUnsignedLong(obj);
3429 if (!PyErr_Occurred()) {
3430 if (val) *val = v;
3431 return SWIG_AddCast(SWIG_OK);
3432 } else {
3433 PyErr_Clear();
3434 }
3435 if (!dispatch) {
3436 double d;
3437 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3438 // Largest double not larger than ULONG_MAX (not portably calculated easily)
3439 // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
3440 // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
3441 const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
3442 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
3443 if (val) *val = (unsigned long)(d);
3444 return res;
3445 }
3446 }
3447 }
3448#endif
3449 return SWIG_TypeError;
3450}
3451
3452
3453SWIGINTERN int
3454SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3455{
3456 unsigned long v;
3457 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3458 if (SWIG_IsOK(res)) {
3459 if ((v > UINT_MAX)) {
3460 return SWIG_OverflowError;
3461 } else {
3462 if (val) *val = (unsigned int)(v);
3463 }
3464 }
3465 return res;
3466}
3467
3468
3469SWIGINTERNINLINE PyObject*
3471{
3472 return PyInt_FromSize_t((size_t) value);
3473}
3474
3475
3478{
3479 static int init = 0;
3480 static swig_type_info* info = 0;
3481 if (!init) {
3482 info = SWIG_TypeQuery("_p_char");
3483 init = 1;
3484 }
3485 return info;
3486}
3487
3488
3489/* Return string from Python obj. NOTE: obj must remain in scope in order
3490 to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
3491SWIGINTERN int
3492SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
3493{
3494#if PY_VERSION_HEX>=0x03000000
3495#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3496 if (PyBytes_Check(obj))
3497#else
3498 if (PyUnicode_Check(obj))
3499#endif
3500#else
3501 if (PyString_Check(obj))
3502#endif
3503 {
3504 char *cstr; Py_ssize_t len;
3505 PyObject *bytes = NULL;
3506 int ret = SWIG_OK;
3507 if (alloc)
3508 *alloc = SWIG_OLDOBJ;
3509#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3510 if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
3511 return SWIG_TypeError;
3512#else
3513 cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
3514 if (!cstr)
3515 return SWIG_TypeError;
3516 /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
3517 if (bytes && cptr) {
3518 if (alloc) {
3519 cstr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3520 *alloc = SWIG_NEWOBJ;
3521 } else {
3522 /* alloc must be set in order to clean up allocated memory */
3523 return SWIG_RuntimeError;
3524 }
3525 }
3526#endif
3527 if (cptr) *cptr = cstr;
3528 if (psize) *psize = len + 1;
3529 Py_XDECREF(bytes);
3530 return ret;
3531 } else {
3532#if defined(SWIG_PYTHON_2_UNICODE)
3533#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3534#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3535#endif
3536#if PY_VERSION_HEX<0x03000000
3537 if (PyUnicode_Check(obj)) {
3538 char *cstr; Py_ssize_t len;
3539 if (!alloc && cptr) {
3540 return SWIG_RuntimeError;
3541 }
3542 obj = PyUnicode_AsUTF8String(obj);
3543 if (!obj)
3544 return SWIG_TypeError;
3545 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3546 if (cptr) {
3547 if (alloc) *alloc = SWIG_NEWOBJ;
3548 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3549 }
3550 if (psize) *psize = len + 1;
3551
3552 Py_XDECREF(obj);
3553 return SWIG_OK;
3554 } else {
3555 Py_XDECREF(obj);
3556 }
3557 }
3558#endif
3559#endif
3560
3561 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3562 if (pchar_descriptor) {
3563 void* vptr = 0;
3564 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3565 if (cptr) *cptr = (char *) vptr;
3566 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3567 if (alloc) *alloc = SWIG_OLDOBJ;
3568 return SWIG_OK;
3569 }
3570 }
3571 }
3572 return SWIG_TypeError;
3573}
3574
3575
3576SWIGINTERN int
3577SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3578{
3579 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3580 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3581 if (SWIG_IsOK(res)) {
3582 /* special case of single char conversion when we don't need space for NUL */
3583 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3584 if (csize <= size) {
3585 if (val) {
3586 if (csize) memcpy(val, cptr, csize*sizeof(char));
3587 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3588 }
3589 if (alloc == SWIG_NEWOBJ) {
3590 free((char*)cptr);
3591 res = SWIG_DelNewMask(res);
3592 }
3593 return res;
3594 }
3595 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3596 }
3597 return SWIG_TypeError;
3598}
3599
3600
3601SWIGINTERNINLINE PyObject *
3602SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3603{
3604 if (carray) {
3605 if (size > INT_MAX) {
3606 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3607 return pchar_descriptor ?
3608 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3609 } else {
3610#if PY_VERSION_HEX >= 0x03000000
3611#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3612 return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3613#else
3614 return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3615#endif
3616#else
3617 return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3618#endif
3619 }
3620 } else {
3621 return SWIG_Py_Void();
3622 }
3623}
3624
3625
3626SWIGINTERN size_t
3627SWIG_strnlen(const char* s, size_t maxlen)
3628{
3629 const char *p;
3630 for (p = s; maxlen-- && *p; p++)
3631 ;
3632 return p - s;
3633}
3634
3635
3636
3637
3638
3639#define t_output_helper SWIG_Python_AppendOutput
3640
3641
3642SWIGINTERN int
3643SWIG_AsVal_char (PyObject * obj, char *val)
3644{
3645 int res = SWIG_AsCharArray(obj, val, 1);
3646 if (!SWIG_IsOK(res)) {
3647 long v;
3648 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3649 if (SWIG_IsOK(res)) {
3650 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3651 if (val) *val = (char)(v);
3652 } else {
3653 res = SWIG_OverflowError;
3654 }
3655 }
3656 }
3657 return res;
3658}
3659
3660#ifdef __cplusplus
3661extern "C" {
3662#endif
3663
3664 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3665
3666// some really twisted stuff to allow calling a single precision library from python
3667 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3668 {
3669 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3670 mindims, maxdims );
3671 if ( !tmp )
3672 {
3673 // could be an incoming long array which can't be "safely" converted, do it anyway
3674 if ( PyArray_Check( in ) )
3675 {
3676 PyErr_Clear();
3677 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3678 }
3679 }
3680 return tmp;
3681 }
3682
3683
3684#define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3685
3686SWIGINTERN PyObject *_wrap_pltr0(PyObject *self, PyObject *args) {
3687 PyObject *resultobj = 0;
3688 PLFLT arg1 ;
3689 PLFLT arg2 ;
3690 PLFLT *arg3 = (PLFLT *) 0 ;
3691 PLFLT *arg4 = (PLFLT *) 0 ;
3692 PLPointer arg5 = (PLPointer) 0 ;
3693 double val1 ;
3694 int ecode1 = 0 ;
3695 double val2 ;
3696 int ecode2 = 0 ;
3697 PLFLT temp3 ;
3698 int res3 = SWIG_TMPOBJ ;
3699 PLFLT temp4 ;
3700 int res4 = SWIG_TMPOBJ ;
3701 PyObject *swig_obj[2] ;
3702
3703 arg3 = &temp3;
3704 arg4 = &temp4;
3705 {
3706 arg5 = NULL;
3707 }
3708 (void)self;
3709 if (!SWIG_Python_UnpackTuple(args, "pltr0", 2, 2, swig_obj)) SWIG_fail;
3710 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3711 if (!SWIG_IsOK(ecode1)) {
3712 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3713 }
3714 arg1 = (PLFLT)(val1);
3715 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3716 if (!SWIG_IsOK(ecode2)) {
3717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3718 }
3719 arg2 = (PLFLT)(val2);
3720 pltr0(arg1,arg2,arg3,arg4,arg5);
3721 resultobj = SWIG_Py_Void();
3722 if (SWIG_IsTmpObj(res3)) {
3723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3724 } else {
3725 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3726 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3727 }
3728 if (SWIG_IsTmpObj(res4)) {
3729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3730 } else {
3731 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3733 }
3734 return resultobj;
3735fail:
3736 return NULL;
3737}
3738
3739
3740
3741 PyArrayObject *pltr_xg, *pltr_yg;
3744
3745 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3746 void cleanup_PLcGrid1( void );
3747 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3748 void cleanup_PLcGrid2( void );
3749
3750 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3751 {
3752 // fprintf(stderr, "marshal PLcGrid1\n");
3753 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3754 {
3755 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3756 return NULL;
3757 }
3758 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3759 NPY_PLFLT, 1, 1 );
3760 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3761 NPY_PLFLT, 1, 1 );
3762 if ( pltr_xg == 0 || pltr_yg == 0 )
3763 {
3764 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3765 return NULL;
3766 }
3767 tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3768 tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3769 if ( isimg == 0 )
3770 {
3771 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3772 {
3773 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3774 return NULL;
3775 }
3776 }
3777 else
3778 {
3779 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3780 {
3781 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3782 return NULL;
3783 }
3784 }
3785 tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3786 tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3787 return &tmpGrid1;
3788 }
3789
3790 void cleanup_PLcGrid1( void )
3791 {
3792 // fprintf(stderr, "cleanup PLcGrid1\n");
3793 Py_CLEAR( pltr_xg );
3794 Py_CLEAR( pltr_yg );
3795 }
3796
3797 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3798 {
3799 int i, size;
3800 // fprintf(stderr, "marshal PLcGrid2\n");
3801 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3802 {
3803 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3804 return NULL;
3805 }
3806 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3807 NPY_PLFLT, 2, 2 );
3808 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3809 NPY_PLFLT, 2, 2 );
3810 if ( pltr_xg == 0 || pltr_yg == 0 )
3811 {
3812 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3813 return NULL;
3814 }
3815 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3816 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3817 {
3818 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3819 return NULL;
3820 }
3821 tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3822 tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3823 if ( isimg == 0 )
3824 {
3825 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3826 {
3827 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3828 return NULL;
3829 }
3830 }
3831 else
3832 {
3833 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3834 {
3835 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3836 return NULL;
3837 }
3838 }
3839 size = tmpGrid2.ny;
3840 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3841 for ( i = 0; i < tmpGrid2.nx; i++ )
3842 tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3843 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3844 for ( i = 0; i < tmpGrid2.nx; i++ )
3845 tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3846 return &tmpGrid2;
3847 }
3848
3849 void cleanup_PLcGrid2( void )
3850 {
3851 // fprintf(stderr, "cleanup PLcGrid2\n");
3852 free( tmpGrid2.xg );
3853 free( tmpGrid2.yg );
3854 Py_CLEAR( pltr_xg );
3855 Py_CLEAR( pltr_yg );
3856 }
3857
3858SWIGINTERN PyObject *_wrap_pltr1(PyObject *self, PyObject *args) {
3859 PyObject *resultobj = 0;
3860 PLFLT arg1 ;
3861 PLFLT arg2 ;
3862 PLFLT *arg3 = (PLFLT *) 0 ;
3863 PLFLT *arg4 = (PLFLT *) 0 ;
3864 PLcGrid *arg5 = (PLcGrid *) 0 ;
3865 double val1 ;
3866 int ecode1 = 0 ;
3867 double val2 ;
3868 int ecode2 = 0 ;
3869 PLFLT temp3 ;
3870 int res3 = SWIG_TMPOBJ ;
3871 PLFLT temp4 ;
3872 int res4 = SWIG_TMPOBJ ;
3873 PyObject *swig_obj[3] ;
3874
3875 arg3 = &temp3;
3876 arg4 = &temp4;
3877 (void)self;
3878 if (!SWIG_Python_UnpackTuple(args, "pltr1", 3, 3, swig_obj)) SWIG_fail;
3879 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3880 if (!SWIG_IsOK(ecode1)) {
3881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3882 }
3883 arg1 = (PLFLT)(val1);
3884 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3885 if (!SWIG_IsOK(ecode2)) {
3886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3887 }
3888 arg2 = (PLFLT)(val2);
3889 {
3890 arg5 = marshal_PLcGrid1( swig_obj[2], 0 );
3891 if ( !arg5 )
3892 return NULL;
3893 }
3894 pltr1(arg1,arg2,arg3,arg4,arg5);
3895 resultobj = SWIG_Py_Void();
3896 if (SWIG_IsTmpObj(res3)) {
3897 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3898 } else {
3899 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3900 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3901 }
3902 if (SWIG_IsTmpObj(res4)) {
3903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3904 } else {
3905 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3906 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3907 }
3908 {
3910 }
3911 return resultobj;
3912fail:
3913 {
3915 }
3916 return NULL;
3917}
3918
3919
3920SWIGINTERN PyObject *_wrap_pltr2(PyObject *self, PyObject *args) {
3921 PyObject *resultobj = 0;
3922 PLFLT arg1 ;
3923 PLFLT arg2 ;
3924 PLFLT *arg3 = (PLFLT *) 0 ;
3925 PLFLT *arg4 = (PLFLT *) 0 ;
3926 PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3927 double val1 ;
3928 int ecode1 = 0 ;
3929 double val2 ;
3930 int ecode2 = 0 ;
3931 PLFLT temp3 ;
3932 int res3 = SWIG_TMPOBJ ;
3933 PLFLT temp4 ;
3934 int res4 = SWIG_TMPOBJ ;
3935 PyObject *swig_obj[3] ;
3936
3937 arg3 = &temp3;
3938 arg4 = &temp4;
3939 (void)self;
3940 if (!SWIG_Python_UnpackTuple(args, "pltr2", 3, 3, swig_obj)) SWIG_fail;
3941 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3942 if (!SWIG_IsOK(ecode1)) {
3943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3944 }
3945 arg1 = (PLFLT)(val1);
3946 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3947 if (!SWIG_IsOK(ecode2)) {
3948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3949 }
3950 arg2 = (PLFLT)(val2);
3951 {
3952 arg5 = marshal_PLcGrid2( swig_obj[2], 0 );
3953 if ( !arg5 )
3954 return NULL;
3955 }
3956 pltr2(arg1,arg2,arg3,arg4,arg5);
3957 resultobj = SWIG_Py_Void();
3958 if (SWIG_IsTmpObj(res3)) {
3959 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
3960 } else {
3961 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3962 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
3963 }
3964 if (SWIG_IsTmpObj(res4)) {
3965 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
3966 } else {
3967 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
3969 }
3970 {
3972 }
3973 return resultobj;
3974fail:
3975 {
3977 }
3978 return NULL;
3979}
3980
3981
3982
3983 // helper code for handling the callback
3984#if 0
3985 static PyInterpreterState *save_interp = NULL;
3986#endif
3988 PyObject* python_pltr = NULL;
3989 PyObject* python_f2eval = NULL;
3990 PyObject* python_ct = NULL;
3991 PyObject* python_mapform = NULL;
3992 PyObject* python_label = NULL;
3993
3994#if 0
3995#define MY_BLOCK_THREADS { \
3996 PyThreadState *prev_state, *new_state; \
3997 /* need to have started a thread at some stage */ \
3998 /* for the following to work */ \
3999 PyEval_AcquireLock(); \
4000 new_state = PyThreadState_New( save_interp ); \
4001 prev_state = PyThreadState_Swap( new_state );
4002#define MY_UNBLOCK_THREADS \
4003 new_state = PyThreadState_Swap( prev_state ); \
4004 PyThreadState_Clear( new_state ); \
4005 PyEval_ReleaseLock(); \
4006 PyThreadState_Delete( new_state ); \
4007 }
4008#else
4009#define MY_BLOCK_THREADS
4010#define MY_UNBLOCK_THREADS
4011#endif
4012
4013// Function prototypes
4014 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
4016 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
4017 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
4018 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
4019 pltr_func marshal_pltr( PyObject* input );
4020 void cleanup_pltr( void );
4021 ct_func marshal_ct( PyObject* input );
4022 void cleanup_ct( void );
4023 mapform_func marshal_mapform( PyObject* input );
4024 void cleanup_mapform( void );
4025 PLPointer marshal_PLPointer( PyObject* input, int isimg );
4026 void cleanup_PLPointer( void );
4027
4028
4029// This is the callback that gets handed to the C code. It, in turn, calls the Python callback
4030
4031 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
4032 {
4033 PyObject *pdata, *arglist, *result;
4034 PyArrayObject *tmp;
4035
4036 // the data argument is acutally a pointer to a python object
4037 pdata = (PyObject *) data;
4038 if ( data == NULL )
4039 {
4040 pdata = Py_None;
4041 }
4042 if ( python_pltr ) // if not something is terribly wrong
4043 { // hold a reference to the data object
4044 Py_XINCREF( pdata );
4045 // grab the Global Interpreter Lock to be sure threads don't mess us up
4047 // build the argument list
4048#ifdef PL_DOUBLE
4049 arglist = Py_BuildValue( "(ddO)", x, y, pdata );
4050#else
4051 arglist = Py_BuildValue( "(ffO)", x, y, pdata );
4052#endif
4053 if ( arglist == NULL )
4054 {
4055 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
4056 *tx = *ty = 0;
4057 return;
4058 }
4059 // call the python function
4060 result = PyEval_CallObject( python_pltr, arglist );
4061 // release the argument list
4062 Py_CLEAR( arglist );
4063 // check and unpack the result
4064 if ( result == NULL )
4065 {
4066 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
4067 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
4068 *tx = *ty = 0;
4069 }
4070 else
4071 {
4072 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
4073 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
4074 {
4075 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
4076 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
4077 *tx = *ty = 0;
4078 }
4079 else
4080 {
4081 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
4082 *tx = t[0];
4083 *ty = t[1];
4084 Py_CLEAR( tmp );
4085 }
4086 }
4087 // release the result
4088 Py_CLEAR( result );
4089 // release the global interpreter lock
4091 }
4092 }
4093
4095 {
4096 PyObject *pdata, *arglist, *result;
4097 PLFLT fresult = 0.0;
4098
4099 // the data argument is acutally a pointer to a python object
4100 pdata = (PyObject *) data;
4101 if ( python_f2eval ) // if not something is terribly wrong
4102 { // hold a reference to the data object
4103 Py_XINCREF( pdata );
4104 // grab the Global Interpreter Lock to be sure threads don't mess us up
4106 // build the argument list
4107 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
4108 // call the python function
4109 result = PyEval_CallObject( python_f2eval, arglist );
4110 // release the argument list
4111 Py_CLEAR( arglist );
4112 // check and unpack the result
4113 if ( !PyFloat_Check( result ) )
4114 {
4115 fprintf( stderr, "f2eval callback must return a float\n" );
4116 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
4117 }
4118 else
4119 {
4120 // should I test the type here?
4121 fresult = (PLFLT) PyFloat_AsDouble( result );
4122 }
4123 // release the result
4124 Py_CLEAR( result );
4125 // release the global interpreter lock
4127 }
4128 return fresult;
4129 }
4130
4131 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
4132 {
4133 PyObject *pdata, *arglist, *result, *unicode_string;
4134 char *pystring;
4135
4136 // the data argument is acutally a pointer to a python object
4137 if ( data )
4138 pdata = (PyObject *) data;
4139 else
4140 pdata = Py_None;
4141 if ( python_label ) // if not something is terribly wrong
4142 { // hold a reference to the data object
4143 Py_XINCREF( pdata );
4144 // grab the Global Interpreter Lock to be sure threads don't mess us up
4146 // build the argument list
4147#ifdef PL_DOUBLE
4148 arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
4149#else
4150 arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
4151#endif
4152 // call the python function
4153 result = PyEval_CallObject( python_label, arglist );
4154 // release the argument list
4155 //Py_CLEAR(arglist);
4156 // check and unpack the result
4157 if ( result == NULL )
4158 {
4159 fprintf( stderr, "label callback failed with 3 arguments\n" );
4160 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
4161 }
4162 else if ( PyString_Check( result ) )
4163 {
4164 // should I test the type here?
4165 pystring = PyString_AsString( result );
4166 strncpy( string, pystring, len );
4167 }
4168 else if ( PyUnicode_Check( result ) )
4169 {
4170 // unicode_string is never freed? memory leak here?
4171 unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
4172 pystring = PyBytes_AS_STRING( unicode_string );
4173 // len may be different then the byte string length w/ unicode?
4174 strncpy( string, pystring, len );
4175 }
4176 else
4177 {
4178 fprintf( stderr, "label callback must return a string\n" );
4179 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
4180 }
4181 // release the result
4182 Py_CLEAR( result );
4183 // release the global interpreter lock
4185 }
4186 }
4187
4188 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
4189 {
4190 PyObject *px, *py, *pdata, *arglist, *result;
4191 npy_intp n;
4192 n = 1;
4193
4194 // the data argument is acutally a pointer to a python object
4195 pdata = (PyObject *) data;
4196 if ( data == NULL )
4197 {
4198 pdata = Py_None;
4199 }
4200 if ( python_ct ) // if not something is terribly wrong
4201 { // hold a reference to the data object
4202 Py_XINCREF( pdata );
4203 // grab the Global Interpreter Lock to be sure threads don't mess us up
4205 // build the argument list
4206 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
4207 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
4208 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
4209 // call the python function
4210 result = PyEval_CallObject( python_ct, arglist );
4211 // release the argument list
4212 Py_CLEAR( arglist );
4213 Py_CLEAR( px );
4214 Py_CLEAR( py );
4215 Py_CLEAR( pdata );
4216 // check and unpack the result
4217 if ( result == NULL )
4218 {
4219 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
4220 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
4221 }
4222 // release the result
4223 Py_CLEAR( result );
4224 // release the global interpreter lock
4226 }
4227 }
4228
4230 {
4231 PyObject *px, *py, *arglist, *result;
4232 // PyArrayObject *tmpx, *tmpy;
4233// PLFLT *xx, *yy;
4234// PLINT i;
4235 npy_intp nn;
4236 nn = n;
4237
4238 if ( python_mapform ) // if not something is terribly wrong
4239 { // grab the Global Interpreter Lock to be sure threads don't mess us up
4241 // build the argument list
4242#ifdef PL_HAVE_PTHREAD
4243 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
4244 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
4245#else
4246 px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
4247 py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
4248#endif
4249 arglist = Py_BuildValue( "(iOO)", n, px, py );
4250 // call the python function
4251 result = PyEval_CallObject( python_mapform, arglist );
4252 // release the argument list
4253 Py_CLEAR( arglist );
4254 Py_CLEAR( px );
4255 Py_CLEAR( py );
4256 // check and unpack the result
4257 if ( result == NULL )
4258 {
4259 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
4260 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
4261 }
4262 // release the result
4263 Py_CLEAR( result );
4264 // release the global interpreter lock
4266 }
4267 }
4268
4269// marshal the pltr function pointer argument
4270 pltr_func marshal_pltr( PyObject* input )
4271 {
4272 pltr_func result = do_pltr_callback;
4273 PyObject * rep = PyObject_Repr( input );
4274 if ( rep )
4275 {
4276 // Memory leaks here? str and uni_str are not freed?
4277 char* str;
4278 if ( PyUnicode_Check( rep ) )
4279 {
4280 PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
4281 str = PyBytes_AS_STRING( uni_str );
4282 }
4283 else
4284 {
4285 str = PyString_AsString( rep );
4286 }
4287 if ( strstr( str, "function pltr0" ) != 0 )
4288 {
4289 result = pltr0;
4290 pltr_type = CB_0;
4291 python_pltr = NULL;
4292 }
4293 else if ( strstr( str, "function pltr1" ) != 0 )
4294 {
4295 result = pltr1;
4296 pltr_type = CB_1;
4297 python_pltr = NULL;
4298 }
4299 else if ( strstr( str, "function pltr2" ) != 0 )
4300 {
4301 result = pltr2;
4302 pltr_type = CB_2;
4303 python_pltr = NULL;
4304 }
4305 else
4306 {
4307 python_pltr = input;
4309 Py_XINCREF( input );
4310 }
4311 Py_CLEAR( rep );
4312 }
4313 else
4314 {
4315 python_pltr = input;
4317 Py_XINCREF( input );
4318 }
4319 return result;
4320 }
4321
4322 void cleanup_pltr( void )
4323 {
4324 Py_CLEAR( python_pltr );
4325 python_pltr = 0;
4326 }
4327
4328// marshal the ct function pointer argument
4329 ct_func marshal_ct( PyObject* input )
4330 {
4331 ct_func result = do_ct_callback;
4332 python_ct = input;
4333 Py_XINCREF( input );
4334 return result;
4335 }
4336
4337 void cleanup_ct( void )
4338 {
4339 Py_CLEAR( python_ct );
4340 python_ct = 0;
4341 }
4342
4343// marshal the mapform function pointer argument
4345 {
4347 python_mapform = input;
4348 Py_XINCREF( input );
4349 return result;
4350 }
4351
4352 void cleanup_mapform( void )
4353 {
4354 Py_CLEAR( python_mapform );
4355 python_mapform = 0;
4356 }
4357
4358 PLPointer marshal_PLPointer( PyObject* input, int isimg )
4359 {
4360 PLPointer result = NULL;
4361 switch ( pltr_type )
4362 {
4363 case CB_0:
4364 break;
4365 case CB_1:
4366 if ( input != Py_None )
4367 result = marshal_PLcGrid1( input, isimg );
4368 break;
4369 case CB_2:
4370 if ( input != Py_None )
4371 result = marshal_PLcGrid2( input, isimg );
4372 break;
4373 case CB_Python:
4374 Py_XINCREF( input );
4375 result = (PLPointer *) input;
4376 break;
4377 default:
4378 fprintf( stderr, "pltr_type is invalid\n" );
4379 }
4380 return result;
4381 }
4382
4384 {
4385 switch ( pltr_type )
4386 {
4387 case CB_0:
4388 break;
4389 case CB_1:
4391 break;
4392 case CB_2:
4394 break;
4395 case CB_Python:
4396 Py_CLEAR( python_pltr );
4397 break;
4398 default:
4399 fprintf( stderr, "pltr_type is invalid\n" );
4400 }
4401 python_pltr = 0;
4402 pltr_type = CB_0;
4403 }
4404
4405
4406
4407SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args) {
4408 PyObject *resultobj = 0;
4409 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4410 int arg2 ;
4411 void *argp1 = 0 ;
4412 int res1 = 0 ;
4413 int val2 ;
4414 int ecode2 = 0 ;
4415 PyObject *swig_obj[2] ;
4416
4417 (void)self;
4418 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_type_set", 2, 2, swig_obj)) SWIG_fail;
4419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4420 if (!SWIG_IsOK(res1)) {
4421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4422 }
4423 arg1 = (PLGraphicsIn *)(argp1);
4424 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4425 if (!SWIG_IsOK(ecode2)) {
4426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4427 }
4428 arg2 = (int)(val2);
4429 if (arg1) (arg1)->type = arg2;
4430 resultobj = SWIG_Py_Void();
4431 return resultobj;
4432fail:
4433 return NULL;
4434}
4435
4436
4437SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args) {
4438 PyObject *resultobj = 0;
4439 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4440 void *argp1 = 0 ;
4441 int res1 = 0 ;
4442 PyObject *swig_obj[1] ;
4443 int result;
4444
4445 (void)self;
4446 if (!args) SWIG_fail;
4447 swig_obj[0] = args;
4448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4449 if (!SWIG_IsOK(res1)) {
4450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4451 }
4452 arg1 = (PLGraphicsIn *)(argp1);
4453 result = (int) ((arg1)->type);
4454 resultobj = SWIG_From_int((int)(result));
4455 return resultobj;
4456fail:
4457 return NULL;
4458}
4459
4460
4461SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args) {
4462 PyObject *resultobj = 0;
4463 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4464 unsigned int arg2 ;
4465 void *argp1 = 0 ;
4466 int res1 = 0 ;
4467 unsigned int val2 ;
4468 int ecode2 = 0 ;
4469 PyObject *swig_obj[2] ;
4470
4471 (void)self;
4472 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_state_set", 2, 2, swig_obj)) SWIG_fail;
4473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4474 if (!SWIG_IsOK(res1)) {
4475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4476 }
4477 arg1 = (PLGraphicsIn *)(argp1);
4478 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4479 if (!SWIG_IsOK(ecode2)) {
4480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4481 }
4482 arg2 = (unsigned int)(val2);
4483 if (arg1) (arg1)->state = arg2;
4484 resultobj = SWIG_Py_Void();
4485 return resultobj;
4486fail:
4487 return NULL;
4488}
4489
4490
4491SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args) {
4492 PyObject *resultobj = 0;
4493 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4494 void *argp1 = 0 ;
4495 int res1 = 0 ;
4496 PyObject *swig_obj[1] ;
4497 unsigned int result;
4498
4499 (void)self;
4500 if (!args) SWIG_fail;
4501 swig_obj[0] = args;
4502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4503 if (!SWIG_IsOK(res1)) {
4504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4505 }
4506 arg1 = (PLGraphicsIn *)(argp1);
4507 result = (unsigned int) ((arg1)->state);
4508 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4509 return resultobj;
4510fail:
4511 return NULL;
4512}
4513
4514
4515SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args) {
4516 PyObject *resultobj = 0;
4517 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4518 unsigned int arg2 ;
4519 void *argp1 = 0 ;
4520 int res1 = 0 ;
4521 unsigned int val2 ;
4522 int ecode2 = 0 ;
4523 PyObject *swig_obj[2] ;
4524
4525 (void)self;
4526 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_keysym_set", 2, 2, swig_obj)) SWIG_fail;
4527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4528 if (!SWIG_IsOK(res1)) {
4529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4530 }
4531 arg1 = (PLGraphicsIn *)(argp1);
4532 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4533 if (!SWIG_IsOK(ecode2)) {
4534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4535 }
4536 arg2 = (unsigned int)(val2);
4537 if (arg1) (arg1)->keysym = arg2;
4538 resultobj = SWIG_Py_Void();
4539 return resultobj;
4540fail:
4541 return NULL;
4542}
4543
4544
4545SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args) {
4546 PyObject *resultobj = 0;
4547 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4548 void *argp1 = 0 ;
4549 int res1 = 0 ;
4550 PyObject *swig_obj[1] ;
4551 unsigned int result;
4552
4553 (void)self;
4554 if (!args) SWIG_fail;
4555 swig_obj[0] = args;
4556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4557 if (!SWIG_IsOK(res1)) {
4558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4559 }
4560 arg1 = (PLGraphicsIn *)(argp1);
4561 result = (unsigned int) ((arg1)->keysym);
4562 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4563 return resultobj;
4564fail:
4565 return NULL;
4566}
4567
4568
4569SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args) {
4570 PyObject *resultobj = 0;
4571 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4572 unsigned int arg2 ;
4573 void *argp1 = 0 ;
4574 int res1 = 0 ;
4575 unsigned int val2 ;
4576 int ecode2 = 0 ;
4577 PyObject *swig_obj[2] ;
4578
4579 (void)self;
4580 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_button_set", 2, 2, swig_obj)) SWIG_fail;
4581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4582 if (!SWIG_IsOK(res1)) {
4583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4584 }
4585 arg1 = (PLGraphicsIn *)(argp1);
4586 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4587 if (!SWIG_IsOK(ecode2)) {
4588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4589 }
4590 arg2 = (unsigned int)(val2);
4591 if (arg1) (arg1)->button = arg2;
4592 resultobj = SWIG_Py_Void();
4593 return resultobj;
4594fail:
4595 return NULL;
4596}
4597
4598
4599SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args) {
4600 PyObject *resultobj = 0;
4601 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4602 void *argp1 = 0 ;
4603 int res1 = 0 ;
4604 PyObject *swig_obj[1] ;
4605 unsigned int result;
4606
4607 (void)self;
4608 if (!args) SWIG_fail;
4609 swig_obj[0] = args;
4610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4611 if (!SWIG_IsOK(res1)) {
4612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4613 }
4614 arg1 = (PLGraphicsIn *)(argp1);
4615 result = (unsigned int) ((arg1)->button);
4616 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4617 return resultobj;
4618fail:
4619 return NULL;
4620}
4621
4622
4623SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args) {
4624 PyObject *resultobj = 0;
4625 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4626 PLINT arg2 ;
4627 void *argp1 = 0 ;
4628 int res1 = 0 ;
4629 int val2 ;
4630 int ecode2 = 0 ;
4631 PyObject *swig_obj[2] ;
4632
4633 (void)self;
4634 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_subwindow_set", 2, 2, swig_obj)) SWIG_fail;
4635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4636 if (!SWIG_IsOK(res1)) {
4637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4638 }
4639 arg1 = (PLGraphicsIn *)(argp1);
4640 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4641 if (!SWIG_IsOK(ecode2)) {
4642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4643 }
4644 arg2 = (PLINT)(val2);
4645 if (arg1) (arg1)->subwindow = arg2;
4646 resultobj = SWIG_Py_Void();
4647 return resultobj;
4648fail:
4649 return NULL;
4650}
4651
4652
4653SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args) {
4654 PyObject *resultobj = 0;
4655 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4656 void *argp1 = 0 ;
4657 int res1 = 0 ;
4658 PyObject *swig_obj[1] ;
4659 PLINT result;
4660
4661 (void)self;
4662 if (!args) SWIG_fail;
4663 swig_obj[0] = args;
4664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4665 if (!SWIG_IsOK(res1)) {
4666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4667 }
4668 arg1 = (PLGraphicsIn *)(argp1);
4669 result = (PLINT) ((arg1)->subwindow);
4670 resultobj = SWIG_From_int((int)(result));
4671 return resultobj;
4672fail:
4673 return NULL;
4674}
4675
4676
4677SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args) {
4678 PyObject *resultobj = 0;
4679 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4680 char *arg2 = (char *) (char *)0 ;
4681 void *argp1 = 0 ;
4682 int res1 = 0 ;
4683 char temp2[16] ;
4684 int res2 ;
4685 PyObject *swig_obj[2] ;
4686
4687 (void)self;
4688 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_string_set", 2, 2, swig_obj)) SWIG_fail;
4689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4690 if (!SWIG_IsOK(res1)) {
4691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4692 }
4693 arg1 = (PLGraphicsIn *)(argp1);
4694 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 16);
4695 if (!SWIG_IsOK(res2)) {
4696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4697 }
4698 arg2 = (char *)(temp2);
4699 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4700 else memset(arg1->string,0,16*sizeof(char));
4701 resultobj = SWIG_Py_Void();
4702 return resultobj;
4703fail:
4704 return NULL;
4705}
4706
4707
4708SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args) {
4709 PyObject *resultobj = 0;
4710 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4711 void *argp1 = 0 ;
4712 int res1 = 0 ;
4713 PyObject *swig_obj[1] ;
4714 char *result = 0 ;
4715
4716 (void)self;
4717 if (!args) SWIG_fail;
4718 swig_obj[0] = args;
4719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4720 if (!SWIG_IsOK(res1)) {
4721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4722 }
4723 arg1 = (PLGraphicsIn *)(argp1);
4724 result = (char *)(char *) ((arg1)->string);
4725 {
4726 size_t size = SWIG_strnlen(result, 16);
4727
4728
4729
4730 resultobj = SWIG_FromCharPtrAndSize(result, size);
4731 }
4732 return resultobj;
4733fail:
4734 return NULL;
4735}
4736
4737
4738SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args) {
4739 PyObject *resultobj = 0;
4740 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4741 int arg2 ;
4742 void *argp1 = 0 ;
4743 int res1 = 0 ;
4744 int val2 ;
4745 int ecode2 = 0 ;
4746 PyObject *swig_obj[2] ;
4747
4748 (void)self;
4749 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pX_set", 2, 2, swig_obj)) SWIG_fail;
4750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4751 if (!SWIG_IsOK(res1)) {
4752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4753 }
4754 arg1 = (PLGraphicsIn *)(argp1);
4755 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4756 if (!SWIG_IsOK(ecode2)) {
4757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4758 }
4759 arg2 = (int)(val2);
4760 if (arg1) (arg1)->pX = arg2;
4761 resultobj = SWIG_Py_Void();
4762 return resultobj;
4763fail:
4764 return NULL;
4765}
4766
4767
4768SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args) {
4769 PyObject *resultobj = 0;
4770 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4771 void *argp1 = 0 ;
4772 int res1 = 0 ;
4773 PyObject *swig_obj[1] ;
4774 int result;
4775
4776 (void)self;
4777 if (!args) SWIG_fail;
4778 swig_obj[0] = args;
4779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4780 if (!SWIG_IsOK(res1)) {
4781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4782 }
4783 arg1 = (PLGraphicsIn *)(argp1);
4784 result = (int) ((arg1)->pX);
4785 resultobj = SWIG_From_int((int)(result));
4786 return resultobj;
4787fail:
4788 return NULL;
4789}
4790
4791
4792SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args) {
4793 PyObject *resultobj = 0;
4794 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4795 int arg2 ;
4796 void *argp1 = 0 ;
4797 int res1 = 0 ;
4798 int val2 ;
4799 int ecode2 = 0 ;
4800 PyObject *swig_obj[2] ;
4801
4802 (void)self;
4803 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pY_set", 2, 2, swig_obj)) SWIG_fail;
4804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4805 if (!SWIG_IsOK(res1)) {
4806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4807 }
4808 arg1 = (PLGraphicsIn *)(argp1);
4809 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4810 if (!SWIG_IsOK(ecode2)) {
4811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4812 }
4813 arg2 = (int)(val2);
4814 if (arg1) (arg1)->pY = arg2;
4815 resultobj = SWIG_Py_Void();
4816 return resultobj;
4817fail:
4818 return NULL;
4819}
4820
4821
4822SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args) {
4823 PyObject *resultobj = 0;
4824 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4825 void *argp1 = 0 ;
4826 int res1 = 0 ;
4827 PyObject *swig_obj[1] ;
4828 int result;
4829
4830 (void)self;
4831 if (!args) SWIG_fail;
4832 swig_obj[0] = args;
4833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4834 if (!SWIG_IsOK(res1)) {
4835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4836 }
4837 arg1 = (PLGraphicsIn *)(argp1);
4838 result = (int) ((arg1)->pY);
4839 resultobj = SWIG_From_int((int)(result));
4840 return resultobj;
4841fail:
4842 return NULL;
4843}
4844
4845
4846SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args) {
4847 PyObject *resultobj = 0;
4848 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4849 PLFLT arg2 ;
4850 void *argp1 = 0 ;
4851 int res1 = 0 ;
4852 double val2 ;
4853 int ecode2 = 0 ;
4854 PyObject *swig_obj[2] ;
4855
4856 (void)self;
4857 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dX_set", 2, 2, swig_obj)) SWIG_fail;
4858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4859 if (!SWIG_IsOK(res1)) {
4860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4861 }
4862 arg1 = (PLGraphicsIn *)(argp1);
4863 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4864 if (!SWIG_IsOK(ecode2)) {
4865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4866 }
4867 arg2 = (PLFLT)(val2);
4868 if (arg1) (arg1)->dX = arg2;
4869 resultobj = SWIG_Py_Void();
4870 return resultobj;
4871fail:
4872 return NULL;
4873}
4874
4875
4876SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args) {
4877 PyObject *resultobj = 0;
4878 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4879 void *argp1 = 0 ;
4880 int res1 = 0 ;
4881 PyObject *swig_obj[1] ;
4882 PLFLT result;
4883
4884 (void)self;
4885 if (!args) SWIG_fail;
4886 swig_obj[0] = args;
4887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4888 if (!SWIG_IsOK(res1)) {
4889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4890 }
4891 arg1 = (PLGraphicsIn *)(argp1);
4892 result = (PLFLT) ((arg1)->dX);
4893 resultobj = SWIG_From_double((double)(result));
4894 return resultobj;
4895fail:
4896 return NULL;
4897}
4898
4899
4900SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args) {
4901 PyObject *resultobj = 0;
4902 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4903 PLFLT arg2 ;
4904 void *argp1 = 0 ;
4905 int res1 = 0 ;
4906 double val2 ;
4907 int ecode2 = 0 ;
4908 PyObject *swig_obj[2] ;
4909
4910 (void)self;
4911 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dY_set", 2, 2, swig_obj)) SWIG_fail;
4912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4913 if (!SWIG_IsOK(res1)) {
4914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4915 }
4916 arg1 = (PLGraphicsIn *)(argp1);
4917 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4918 if (!SWIG_IsOK(ecode2)) {
4919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4920 }
4921 arg2 = (PLFLT)(val2);
4922 if (arg1) (arg1)->dY = arg2;
4923 resultobj = SWIG_Py_Void();
4924 return resultobj;
4925fail:
4926 return NULL;
4927}
4928
4929
4930SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args) {
4931 PyObject *resultobj = 0;
4932 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4933 void *argp1 = 0 ;
4934 int res1 = 0 ;
4935 PyObject *swig_obj[1] ;
4936 PLFLT result;
4937
4938 (void)self;
4939 if (!args) SWIG_fail;
4940 swig_obj[0] = args;
4941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4942 if (!SWIG_IsOK(res1)) {
4943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4944 }
4945 arg1 = (PLGraphicsIn *)(argp1);
4946 result = (PLFLT) ((arg1)->dY);
4947 resultobj = SWIG_From_double((double)(result));
4948 return resultobj;
4949fail:
4950 return NULL;
4951}
4952
4953
4954SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args) {
4955 PyObject *resultobj = 0;
4956 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4957 PLFLT arg2 ;
4958 void *argp1 = 0 ;
4959 int res1 = 0 ;
4960 double val2 ;
4961 int ecode2 = 0 ;
4962 PyObject *swig_obj[2] ;
4963
4964 (void)self;
4965 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wX_set", 2, 2, swig_obj)) SWIG_fail;
4966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4967 if (!SWIG_IsOK(res1)) {
4968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4969 }
4970 arg1 = (PLGraphicsIn *)(argp1);
4971 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4972 if (!SWIG_IsOK(ecode2)) {
4973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
4974 }
4975 arg2 = (PLFLT)(val2);
4976 if (arg1) (arg1)->wX = arg2;
4977 resultobj = SWIG_Py_Void();
4978 return resultobj;
4979fail:
4980 return NULL;
4981}
4982
4983
4984SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args) {
4985 PyObject *resultobj = 0;
4986 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4987 void *argp1 = 0 ;
4988 int res1 = 0 ;
4989 PyObject *swig_obj[1] ;
4990 PLFLT result;
4991
4992 (void)self;
4993 if (!args) SWIG_fail;
4994 swig_obj[0] = args;
4995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4996 if (!SWIG_IsOK(res1)) {
4997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4998 }
4999 arg1 = (PLGraphicsIn *)(argp1);
5000 result = (PLFLT) ((arg1)->wX);
5001 resultobj = SWIG_From_double((double)(result));
5002 return resultobj;
5003fail:
5004 return NULL;
5005}
5006
5007
5008SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args) {
5009 PyObject *resultobj = 0;
5010 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5011 PLFLT arg2 ;
5012 void *argp1 = 0 ;
5013 int res1 = 0 ;
5014 double val2 ;
5015 int ecode2 = 0 ;
5016 PyObject *swig_obj[2] ;
5017
5018 (void)self;
5019 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wY_set", 2, 2, swig_obj)) SWIG_fail;
5020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5021 if (!SWIG_IsOK(res1)) {
5022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5023 }
5024 arg1 = (PLGraphicsIn *)(argp1);
5025 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5026 if (!SWIG_IsOK(ecode2)) {
5027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
5028 }
5029 arg2 = (PLFLT)(val2);
5030 if (arg1) (arg1)->wY = arg2;
5031 resultobj = SWIG_Py_Void();
5032 return resultobj;
5033fail:
5034 return NULL;
5035}
5036
5037
5038SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args) {
5039 PyObject *resultobj = 0;
5040 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5041 void *argp1 = 0 ;
5042 int res1 = 0 ;
5043 PyObject *swig_obj[1] ;
5044 PLFLT result;
5045
5046 (void)self;
5047 if (!args) SWIG_fail;
5048 swig_obj[0] = args;
5049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5050 if (!SWIG_IsOK(res1)) {
5051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5052 }
5053 arg1 = (PLGraphicsIn *)(argp1);
5054 result = (PLFLT) ((arg1)->wY);
5055 resultobj = SWIG_From_double((double)(result));
5056 return resultobj;
5057fail:
5058 return NULL;
5059}
5060
5061
5062SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *self, PyObject *args) {
5063 PyObject *resultobj = 0;
5064 PLGraphicsIn *result = 0 ;
5065
5066 (void)self;
5067 if (!SWIG_Python_UnpackTuple(args, "new_PLGraphicsIn", 0, 0, 0)) SWIG_fail;
5068 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
5070 return resultobj;
5071fail:
5072 return NULL;
5073}
5074
5075
5076SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args) {
5077 PyObject *resultobj = 0;
5078 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5079 void *argp1 = 0 ;
5080 int res1 = 0 ;
5081 PyObject *swig_obj[1] ;
5082
5083 (void)self;
5084 if (!args) SWIG_fail;
5085 swig_obj[0] = args;
5086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
5087 if (!SWIG_IsOK(res1)) {
5088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5089 }
5090 arg1 = (PLGraphicsIn *)(argp1);
5091 free((char *) arg1);
5092 resultobj = SWIG_Py_Void();
5093 return resultobj;
5094fail:
5095 return NULL;
5096}
5097
5098
5099SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5100 PyObject *obj;
5101 if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
5103 return SWIG_Py_Void();
5104}
5105
5106SWIGINTERN PyObject *PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5107 return SWIG_Python_InitShadowInstance(args);
5108}
5109
5110SWIGINTERN PyObject *_wrap_plsxwin(PyObject *self, PyObject *args) {
5111 PyObject *resultobj = 0;
5112 PLINT arg1 ;
5113 int val1 ;
5114 int ecode1 = 0 ;
5115 PyObject *swig_obj[1] ;
5116
5117 (void)self;
5118 if (!args) SWIG_fail;
5119 swig_obj[0] = args;
5120 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5121 if (!SWIG_IsOK(ecode1)) {
5122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
5123 }
5124 arg1 = (PLINT)(val1);
5125 plsxwin(arg1);
5126 resultobj = SWIG_Py_Void();
5127 return resultobj;
5128fail:
5129 return NULL;
5130}
5131
5132
5133SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *self, PyObject *args) {
5134 PyObject *resultobj = 0;
5135 PLINT arg1 ;
5136 PLINT arg2 ;
5137 int val1 ;
5138 int ecode1 = 0 ;
5139 int val2 ;
5140 int ecode2 = 0 ;
5141 PyObject *swig_obj[2] ;
5142
5143 (void)self;
5144 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelformat", 2, 2, swig_obj)) SWIG_fail;
5145 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5146 if (!SWIG_IsOK(ecode1)) {
5147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
5148 }
5149 arg1 = (PLINT)(val1);
5150 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5151 if (!SWIG_IsOK(ecode2)) {
5152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
5153 }
5154 arg2 = (PLINT)(val2);
5155 pl_setcontlabelformat(arg1,arg2);
5156 resultobj = SWIG_Py_Void();
5157 return resultobj;
5158fail:
5159 return NULL;
5160}
5161
5162
5163SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *self, PyObject *args) {
5164 PyObject *resultobj = 0;
5165 PLFLT arg1 ;
5166 PLFLT arg2 ;
5167 PLFLT arg3 ;
5168 PLINT arg4 ;
5169 double val1 ;
5170 int ecode1 = 0 ;
5171 double val2 ;
5172 int ecode2 = 0 ;
5173 double val3 ;
5174 int ecode3 = 0 ;
5175 int val4 ;
5176 int ecode4 = 0 ;
5177 PyObject *swig_obj[4] ;
5178
5179 (void)self;
5180 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelparam", 4, 4, swig_obj)) SWIG_fail;
5181 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5182 if (!SWIG_IsOK(ecode1)) {
5183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
5184 }
5185 arg1 = (PLFLT)(val1);
5186 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5187 if (!SWIG_IsOK(ecode2)) {
5188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
5189 }
5190 arg2 = (PLFLT)(val2);
5191 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5192 if (!SWIG_IsOK(ecode3)) {
5193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
5194 }
5195 arg3 = (PLFLT)(val3);
5196 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5197 if (!SWIG_IsOK(ecode4)) {
5198 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
5199 }
5200 arg4 = (PLINT)(val4);
5201 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
5202 resultobj = SWIG_Py_Void();
5203 return resultobj;
5204fail:
5205 return NULL;
5206}
5207
5208
5209SWIGINTERN PyObject *_wrap_pladv(PyObject *self, PyObject *args) {
5210 PyObject *resultobj = 0;
5211 PLINT arg1 ;
5212 int val1 ;
5213 int ecode1 = 0 ;
5214 PyObject *swig_obj[1] ;
5215
5216 (void)self;
5217 if (!args) SWIG_fail;
5218 swig_obj[0] = args;
5219 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5220 if (!SWIG_IsOK(ecode1)) {
5221 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
5222 }
5223 arg1 = (PLINT)(val1);
5224 pladv(arg1);
5225 resultobj = SWIG_Py_Void();
5226 return resultobj;
5227fail:
5228 return NULL;
5229}
5230
5231
5232SWIGINTERN PyObject *_wrap_plarc(PyObject *self, PyObject *args) {
5233 PyObject *resultobj = 0;
5234 PLFLT arg1 ;
5235 PLFLT arg2 ;
5236 PLFLT arg3 ;
5237 PLFLT arg4 ;
5238 PLFLT arg5 ;
5239 PLFLT arg6 ;
5240 PLFLT arg7 ;
5241 PLBOOL arg8 ;
5242 double val1 ;
5243 int ecode1 = 0 ;
5244 double val2 ;
5245 int ecode2 = 0 ;
5246 double val3 ;
5247 int ecode3 = 0 ;
5248 double val4 ;
5249 int ecode4 = 0 ;
5250 double val5 ;
5251 int ecode5 = 0 ;
5252 double val6 ;
5253 int ecode6 = 0 ;
5254 double val7 ;
5255 int ecode7 = 0 ;
5256 int val8 ;
5257 int ecode8 = 0 ;
5258 PyObject *swig_obj[8] ;
5259
5260 (void)self;
5261 if (!SWIG_Python_UnpackTuple(args, "plarc", 8, 8, swig_obj)) SWIG_fail;
5262 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5263 if (!SWIG_IsOK(ecode1)) {
5264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
5265 }
5266 arg1 = (PLFLT)(val1);
5267 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5268 if (!SWIG_IsOK(ecode2)) {
5269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
5270 }
5271 arg2 = (PLFLT)(val2);
5272 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5273 if (!SWIG_IsOK(ecode3)) {
5274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
5275 }
5276 arg3 = (PLFLT)(val3);
5277 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5278 if (!SWIG_IsOK(ecode4)) {
5279 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
5280 }
5281 arg4 = (PLFLT)(val4);
5282 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5283 if (!SWIG_IsOK(ecode5)) {
5284 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
5285 }
5286 arg5 = (PLFLT)(val5);
5287 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5288 if (!SWIG_IsOK(ecode6)) {
5289 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
5290 }
5291 arg6 = (PLFLT)(val6);
5292 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5293 if (!SWIG_IsOK(ecode7)) {
5294 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
5295 }
5296 arg7 = (PLFLT)(val7);
5297 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5298 if (!SWIG_IsOK(ecode8)) {
5299 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
5300 }
5301 arg8 = (PLBOOL)(val8);
5302 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5303 resultobj = SWIG_Py_Void();
5304 return resultobj;
5305fail:
5306 return NULL;
5307}
5308
5309
5310SWIGINTERN PyObject *_wrap_plaxes(PyObject *self, PyObject *args) {
5311 PyObject *resultobj = 0;
5312 PLFLT arg1 ;
5313 PLFLT arg2 ;
5314 char *arg3 = (char *) 0 ;
5315 PLFLT arg4 ;
5316 PLINT arg5 ;
5317 char *arg6 = (char *) 0 ;
5318 PLFLT arg7 ;
5319 PLINT arg8 ;
5320 double val1 ;
5321 int ecode1 = 0 ;
5322 double val2 ;
5323 int ecode2 = 0 ;
5324 int res3 ;
5325 char *buf3 = 0 ;
5326 int alloc3 = 0 ;
5327 double val4 ;
5328 int ecode4 = 0 ;
5329 int val5 ;
5330 int ecode5 = 0 ;
5331 int res6 ;
5332 char *buf6 = 0 ;
5333 int alloc6 = 0 ;
5334 double val7 ;
5335 int ecode7 = 0 ;
5336 int val8 ;
5337 int ecode8 = 0 ;
5338 PyObject *swig_obj[8] ;
5339
5340 (void)self;
5341 if (!SWIG_Python_UnpackTuple(args, "plaxes", 8, 8, swig_obj)) SWIG_fail;
5342 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5343 if (!SWIG_IsOK(ecode1)) {
5344 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5345 }
5346 arg1 = (PLFLT)(val1);
5347 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5348 if (!SWIG_IsOK(ecode2)) {
5349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5350 }
5351 arg2 = (PLFLT)(val2);
5352 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
5353 if (!SWIG_IsOK(res3)) {
5354 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5355 }
5356 arg3 = (char *)(buf3);
5357 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5358 if (!SWIG_IsOK(ecode4)) {
5359 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5360 }
5361 arg4 = (PLFLT)(val4);
5362 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5363 if (!SWIG_IsOK(ecode5)) {
5364 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5365 }
5366 arg5 = (PLINT)(val5);
5367 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5368 if (!SWIG_IsOK(res6)) {
5369 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5370 }
5371 arg6 = (char *)(buf6);
5372 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5373 if (!SWIG_IsOK(ecode7)) {
5374 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5375 }
5376 arg7 = (PLFLT)(val7);
5377 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5378 if (!SWIG_IsOK(ecode8)) {
5379 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5380 }
5381 arg8 = (PLINT)(val8);
5382 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5383 resultobj = SWIG_Py_Void();
5384 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5385 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5386 return resultobj;
5387fail:
5388 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5389 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5390 return NULL;
5391}
5392
5393
5394SWIGINTERN PyObject *_wrap_plbin(PyObject *self, PyObject *args) {
5395 PyObject *resultobj = 0;
5396 PLINT arg1 ;
5397 PLFLT *arg2 = (PLFLT *) 0 ;
5398 PLFLT *arg3 = (PLFLT *) 0 ;
5399 PLINT arg4 ;
5400 PyArrayObject *tmp1 = NULL ;
5401 PyArrayObject *tmp3 = NULL ;
5402 int val4 ;
5403 int ecode4 = 0 ;
5404 PyObject *swig_obj[3] ;
5405
5406 (void)self;
5407 if (!SWIG_Python_UnpackTuple(args, "plbin", 3, 3, swig_obj)) SWIG_fail;
5408 {
5409 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5410 if ( tmp1 == NULL )
5411 return NULL;
5412 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5413 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5414 }
5415 {
5416 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5417 if ( tmp3 == NULL )
5418 return NULL;
5419 if ( PyArray_DIMS( tmp3 )[0] != Alen )
5420 {
5421 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5422 return NULL;
5423 }
5424 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5425 }
5426 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
5427 if (!SWIG_IsOK(ecode4)) {
5428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5429 }
5430 arg4 = (PLINT)(val4);
5431 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5432 resultobj = SWIG_Py_Void();
5433 {
5434 Py_CLEAR( tmp1 );
5435 }
5436 {
5437 Py_CLEAR( tmp3 );
5438 }
5439 return resultobj;
5440fail:
5441 {
5442 Py_CLEAR( tmp1 );
5443 }
5444 {
5445 Py_CLEAR( tmp3 );
5446 }
5447 return NULL;
5448}
5449
5450
5451SWIGINTERN PyObject *_wrap_plbtime(PyObject *self, PyObject *args) {
5452 PyObject *resultobj = 0;
5453 PLINT *arg1 = (PLINT *) 0 ;
5454 PLINT *arg2 = (PLINT *) 0 ;
5455 PLINT *arg3 = (PLINT *) 0 ;
5456 PLINT *arg4 = (PLINT *) 0 ;
5457 PLINT *arg5 = (PLINT *) 0 ;
5458 PLFLT *arg6 = (PLFLT *) 0 ;
5459 PLFLT arg7 ;
5460 PLINT temp1 ;
5461 int res1 = SWIG_TMPOBJ ;
5462 PLINT temp2 ;
5463 int res2 = SWIG_TMPOBJ ;
5464 PLINT temp3 ;
5465 int res3 = SWIG_TMPOBJ ;
5466 PLINT temp4 ;
5467 int res4 = SWIG_TMPOBJ ;
5468 PLINT temp5 ;
5469 int res5 = SWIG_TMPOBJ ;
5470 PLFLT temp6 ;
5471 int res6 = SWIG_TMPOBJ ;
5472 double val7 ;
5473 int ecode7 = 0 ;
5474 PyObject *swig_obj[1] ;
5475
5476 arg1 = &temp1;
5477 arg2 = &temp2;
5478 arg3 = &temp3;
5479 arg4 = &temp4;
5480 arg5 = &temp5;
5481 arg6 = &temp6;
5482 (void)self;
5483 if (!args) SWIG_fail;
5484 swig_obj[0] = args;
5485 ecode7 = SWIG_AsVal_double(swig_obj[0], &val7);
5486 if (!SWIG_IsOK(ecode7)) {
5487 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5488 }
5489 arg7 = (PLFLT)(val7);
5490 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5491 resultobj = SWIG_Py_Void();
5492 if (SWIG_IsTmpObj(res1)) {
5493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5494 } else {
5495 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5497 }
5498 if (SWIG_IsTmpObj(res2)) {
5499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5500 } else {
5501 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5503 }
5504 if (SWIG_IsTmpObj(res3)) {
5505 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
5506 } else {
5507 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5508 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
5509 }
5510 if (SWIG_IsTmpObj(res4)) {
5511 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
5512 } else {
5513 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5514 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
5515 }
5516 if (SWIG_IsTmpObj(res5)) {
5517 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5518 } else {
5519 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5520 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5521 }
5522 if (SWIG_IsTmpObj(res6)) {
5523 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
5524 } else {
5525 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5526 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
5527 }
5528 return resultobj;
5529fail:
5530 return NULL;
5531}
5532
5533
5534SWIGINTERN PyObject *_wrap_plbop(PyObject *self, PyObject *args) {
5535 PyObject *resultobj = 0;
5536
5537 (void)self;
5538 if (!SWIG_Python_UnpackTuple(args, "plbop", 0, 0, 0)) SWIG_fail;
5539 plbop();
5540 resultobj = SWIG_Py_Void();
5541 return resultobj;
5542fail:
5543 return NULL;
5544}
5545
5546
5547SWIGINTERN PyObject *_wrap_plbox(PyObject *self, PyObject *args) {
5548 PyObject *resultobj = 0;
5549 char *arg1 = (char *) 0 ;
5550 PLFLT arg2 ;
5551 PLINT arg3 ;
5552 char *arg4 = (char *) 0 ;
5553 PLFLT arg5 ;
5554 PLINT arg6 ;
5555 int res1 ;
5556 char *buf1 = 0 ;
5557 int alloc1 = 0 ;
5558 double val2 ;
5559 int ecode2 = 0 ;
5560 int val3 ;
5561 int ecode3 = 0 ;
5562 int res4 ;
5563 char *buf4 = 0 ;
5564 int alloc4 = 0 ;
5565 double val5 ;
5566 int ecode5 = 0 ;
5567 int val6 ;
5568 int ecode6 = 0 ;
5569 PyObject *swig_obj[6] ;
5570
5571 (void)self;
5572 if (!SWIG_Python_UnpackTuple(args, "plbox", 6, 6, swig_obj)) SWIG_fail;
5573 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5574 if (!SWIG_IsOK(res1)) {
5575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5576 }
5577 arg1 = (char *)(buf1);
5578 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5579 if (!SWIG_IsOK(ecode2)) {
5580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5581 }
5582 arg2 = (PLFLT)(val2);
5583 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5584 if (!SWIG_IsOK(ecode3)) {
5585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5586 }
5587 arg3 = (PLINT)(val3);
5588 res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
5589 if (!SWIG_IsOK(res4)) {
5590 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5591 }
5592 arg4 = (char *)(buf4);
5593 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5594 if (!SWIG_IsOK(ecode5)) {
5595 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5596 }
5597 arg5 = (PLFLT)(val5);
5598 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5599 if (!SWIG_IsOK(ecode6)) {
5600 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5601 }
5602 arg6 = (PLINT)(val6);
5603 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5604 resultobj = SWIG_Py_Void();
5605 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5606 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5607 return resultobj;
5608fail:
5609 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5610 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5611 return NULL;
5612}
5613
5614
5615SWIGINTERN PyObject *_wrap_plbox3(PyObject *self, PyObject *args) {
5616 PyObject *resultobj = 0;
5617 char *arg1 = (char *) 0 ;
5618 char *arg2 = (char *) 0 ;
5619 PLFLT arg3 ;
5620 PLINT arg4 ;
5621 char *arg5 = (char *) 0 ;
5622 char *arg6 = (char *) 0 ;
5623 PLFLT arg7 ;
5624 PLINT arg8 ;
5625 char *arg9 = (char *) 0 ;
5626 char *arg10 = (char *) 0 ;
5627 PLFLT arg11 ;
5628 PLINT arg12 ;
5629 int res1 ;
5630 char *buf1 = 0 ;
5631 int alloc1 = 0 ;
5632 int res2 ;
5633 char *buf2 = 0 ;
5634 int alloc2 = 0 ;
5635 double val3 ;
5636 int ecode3 = 0 ;
5637 int val4 ;
5638 int ecode4 = 0 ;
5639 int res5 ;
5640 char *buf5 = 0 ;
5641 int alloc5 = 0 ;
5642 int res6 ;
5643 char *buf6 = 0 ;
5644 int alloc6 = 0 ;
5645 double val7 ;
5646 int ecode7 = 0 ;
5647 int val8 ;
5648 int ecode8 = 0 ;
5649 int res9 ;
5650 char *buf9 = 0 ;
5651 int alloc9 = 0 ;
5652 int res10 ;
5653 char *buf10 = 0 ;
5654 int alloc10 = 0 ;
5655 double val11 ;
5656 int ecode11 = 0 ;
5657 int val12 ;
5658 int ecode12 = 0 ;
5659 PyObject *swig_obj[12] ;
5660
5661 (void)self;
5662 if (!SWIG_Python_UnpackTuple(args, "plbox3", 12, 12, swig_obj)) SWIG_fail;
5663 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5664 if (!SWIG_IsOK(res1)) {
5665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5666 }
5667 arg1 = (char *)(buf1);
5668 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
5669 if (!SWIG_IsOK(res2)) {
5670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5671 }
5672 arg2 = (char *)(buf2);
5673 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5674 if (!SWIG_IsOK(ecode3)) {
5675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5676 }
5677 arg3 = (PLFLT)(val3);
5678 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5679 if (!SWIG_IsOK(ecode4)) {
5680 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5681 }
5682 arg4 = (PLINT)(val4);
5683 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
5684 if (!SWIG_IsOK(res5)) {
5685 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5686 }
5687 arg5 = (char *)(buf5);
5688 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5689 if (!SWIG_IsOK(res6)) {
5690 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5691 }
5692 arg6 = (char *)(buf6);
5693 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5694 if (!SWIG_IsOK(ecode7)) {
5695 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5696 }
5697 arg7 = (PLFLT)(val7);
5698 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5699 if (!SWIG_IsOK(ecode8)) {
5700 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5701 }
5702 arg8 = (PLINT)(val8);
5703 res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
5704 if (!SWIG_IsOK(res9)) {
5705 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5706 }
5707 arg9 = (char *)(buf9);
5708 res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
5709 if (!SWIG_IsOK(res10)) {
5710 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5711 }
5712 arg10 = (char *)(buf10);
5713 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5714 if (!SWIG_IsOK(ecode11)) {
5715 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5716 }
5717 arg11 = (PLFLT)(val11);
5718 ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
5719 if (!SWIG_IsOK(ecode12)) {
5720 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5721 }
5722 arg12 = (PLINT)(val12);
5723 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);
5724 resultobj = SWIG_Py_Void();
5725 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5726 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5727 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5728 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5729 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5730 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5731 return resultobj;
5732fail:
5733 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5734 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5735 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5736 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5737 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5738 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5739 return NULL;
5740}
5741
5742
5743SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *self, PyObject *args) {
5744 PyObject *resultobj = 0;
5745 PLFLT arg1 ;
5746 PLFLT arg2 ;
5747 PLFLT *arg3 = (PLFLT *) 0 ;
5748 PLFLT *arg4 = (PLFLT *) 0 ;
5749 PLINT *arg5 = (PLINT *) 0 ;
5750 double val1 ;
5751 int ecode1 = 0 ;
5752 double val2 ;
5753 int ecode2 = 0 ;
5754 PLFLT temp3 ;
5755 int res3 = SWIG_TMPOBJ ;
5756 PLFLT temp4 ;
5757 int res4 = SWIG_TMPOBJ ;
5758 PLINT temp5 ;
5759 int res5 = SWIG_TMPOBJ ;
5760 PyObject *swig_obj[2] ;
5761
5762 arg3 = &temp3;
5763 arg4 = &temp4;
5764 arg5 = &temp5;
5765 (void)self;
5766 if (!SWIG_Python_UnpackTuple(args, "plcalc_world", 2, 2, swig_obj)) SWIG_fail;
5767 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5768 if (!SWIG_IsOK(ecode1)) {
5769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5770 }
5771 arg1 = (PLFLT)(val1);
5772 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5773 if (!SWIG_IsOK(ecode2)) {
5774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5775 }
5776 arg2 = (PLFLT)(val2);
5777 plcalc_world(arg1,arg2,arg3,arg4,arg5);
5778 resultobj = SWIG_Py_Void();
5779 if (SWIG_IsTmpObj(res3)) {
5780 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
5781 } else {
5782 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5783 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
5784 }
5785 if (SWIG_IsTmpObj(res4)) {
5786 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
5787 } else {
5788 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5789 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
5790 }
5791 if (SWIG_IsTmpObj(res5)) {
5792 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
5793 } else {
5794 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5795 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
5796 }
5797 return resultobj;
5798fail:
5799 return NULL;
5800}
5801
5802
5803SWIGINTERN PyObject *_wrap_plclear(PyObject *self, PyObject *args) {
5804 PyObject *resultobj = 0;
5805
5806 (void)self;
5807 if (!SWIG_Python_UnpackTuple(args, "plclear", 0, 0, 0)) SWIG_fail;
5808 plclear();
5809 resultobj = SWIG_Py_Void();
5810 return resultobj;
5811fail:
5812 return NULL;
5813}
5814
5815
5816SWIGINTERN PyObject *_wrap_plcol0(PyObject *self, PyObject *args) {
5817 PyObject *resultobj = 0;
5818 PLINT arg1 ;
5819 int val1 ;
5820 int ecode1 = 0 ;
5821 PyObject *swig_obj[1] ;
5822
5823 (void)self;
5824 if (!args) SWIG_fail;
5825 swig_obj[0] = args;
5826 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5827 if (!SWIG_IsOK(ecode1)) {
5828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5829 }
5830 arg1 = (PLINT)(val1);
5831 plcol0(arg1);
5832 resultobj = SWIG_Py_Void();
5833 return resultobj;
5834fail:
5835 return NULL;
5836}
5837
5838
5839SWIGINTERN PyObject *_wrap_plcol1(PyObject *self, PyObject *args) {
5840 PyObject *resultobj = 0;
5841 PLFLT arg1 ;
5842 double val1 ;
5843 int ecode1 = 0 ;
5844 PyObject *swig_obj[1] ;
5845
5846 (void)self;
5847 if (!args) SWIG_fail;
5848 swig_obj[0] = args;
5849 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5850 if (!SWIG_IsOK(ecode1)) {
5851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5852 }
5853 arg1 = (PLFLT)(val1);
5854 plcol1(arg1);
5855 resultobj = SWIG_Py_Void();
5856 return resultobj;
5857fail:
5858 return NULL;
5859}
5860
5861
5862SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *self, PyObject *args) {
5863 PyObject *resultobj = 0;
5864 PLFLT arg1 ;
5865 PLFLT arg2 ;
5866 PLFLT arg3 ;
5867 PLINT arg4 ;
5868 PLBOOL arg5 ;
5869 PLINT arg6 ;
5870 PLINT arg7 ;
5871 PLINT arg8 ;
5872 PLINT arg9 ;
5873 PLINT arg10 ;
5874 PLFLT arg11 ;
5875 double val1 ;
5876 int ecode1 = 0 ;
5877 double val2 ;
5878 int ecode2 = 0 ;
5879 double val3 ;
5880 int ecode3 = 0 ;
5881 int val4 ;
5882 int ecode4 = 0 ;
5883 int val5 ;
5884 int ecode5 = 0 ;
5885 int val6 ;
5886 int ecode6 = 0 ;
5887 int val7 ;
5888 int ecode7 = 0 ;
5889 int val8 ;
5890 int ecode8 = 0 ;
5891 int val9 ;
5892 int ecode9 = 0 ;
5893 int val10 ;
5894 int ecode10 = 0 ;
5895 double val11 ;
5896 int ecode11 = 0 ;
5897 PyObject *swig_obj[11] ;
5898
5899 (void)self;
5900 if (!SWIG_Python_UnpackTuple(args, "plconfigtime", 11, 11, swig_obj)) SWIG_fail;
5901 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5902 if (!SWIG_IsOK(ecode1)) {
5903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5904 }
5905 arg1 = (PLFLT)(val1);
5906 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5907 if (!SWIG_IsOK(ecode2)) {
5908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5909 }
5910 arg2 = (PLFLT)(val2);
5911 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5912 if (!SWIG_IsOK(ecode3)) {
5913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5914 }
5915 arg3 = (PLFLT)(val3);
5916 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5917 if (!SWIG_IsOK(ecode4)) {
5918 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5919 }
5920 arg4 = (PLINT)(val4);
5921 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5922 if (!SWIG_IsOK(ecode5)) {
5923 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5924 }
5925 arg5 = (PLBOOL)(val5);
5926 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5927 if (!SWIG_IsOK(ecode6)) {
5928 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5929 }
5930 arg6 = (PLINT)(val6);
5931 ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
5932 if (!SWIG_IsOK(ecode7)) {
5933 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5934 }
5935 arg7 = (PLINT)(val7);
5936 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5937 if (!SWIG_IsOK(ecode8)) {
5938 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5939 }
5940 arg8 = (PLINT)(val8);
5941 ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
5942 if (!SWIG_IsOK(ecode9)) {
5943 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5944 }
5945 arg9 = (PLINT)(val9);
5946 ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
5947 if (!SWIG_IsOK(ecode10)) {
5948 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5949 }
5950 arg10 = (PLINT)(val10);
5951 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5952 if (!SWIG_IsOK(ecode11)) {
5953 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5954 }
5955 arg11 = (PLFLT)(val11);
5956 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5957 resultobj = SWIG_Py_Void();
5958 return resultobj;
5959fail:
5960 return NULL;
5961}
5962
5963
5964SWIGINTERN PyObject *_wrap_plcont(PyObject *self, PyObject *args) {
5965 PyObject *resultobj = 0;
5966 PLFLT **arg1 = (PLFLT **) 0 ;
5967 PLINT arg2 ;
5968 PLINT arg3 ;
5969 PLINT arg4 ;
5970 PLINT arg5 ;
5971 PLINT arg6 ;
5972 PLINT arg7 ;
5973 PLFLT *arg8 = (PLFLT *) 0 ;
5974 PLINT arg9 ;
5975 pltr_func arg10 = (pltr_func) 0 ;
5976 PLPointer arg11 = (PLPointer) 0 ;
5977 PyArrayObject *tmp1 = NULL ;
5978 int val4 ;
5979 int ecode4 = 0 ;
5980 int val5 ;
5981 int ecode5 = 0 ;
5982 int val6 ;
5983 int ecode6 = 0 ;
5984 int val7 ;
5985 int ecode7 = 0 ;
5986 PyArrayObject *tmp8 = NULL ;
5987 PyObject *swig_obj[8] ;
5988
5989 {
5990 python_pltr = 0;
5991 arg10 = NULL;
5992 }
5993 {
5994 arg11 = NULL;
5995 }
5996 (void)self;
5997 if (!SWIG_Python_UnpackTuple(args, "plcont", 6, 8, swig_obj)) SWIG_fail;
5998 {
5999 int i, size;
6000 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
6001 if ( tmp1 == NULL )
6002 return NULL;
6003 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
6004 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
6005 size = arg3;
6006 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
6007 for ( i = 0; i < arg2; i++ )
6008 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
6009 }
6010 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
6011 if (!SWIG_IsOK(ecode4)) {
6012 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
6013 }
6014 arg4 = (PLINT)(val4);
6015 ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
6016 if (!SWIG_IsOK(ecode5)) {
6017 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
6018 }
6019 arg5 = (PLINT)(val5);
6020 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
6021 if (!SWIG_IsOK(ecode6)) {
6022 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
6023 }
6024 arg6 = (PLINT)(val6);
6025 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
6026 if (!SWIG_IsOK(ecode7)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
6028 }
6029 arg7 = (PLINT)(val7);
6030 {
6031 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
6032 if ( tmp8 == NULL )
6033 return NULL;
6034 arg9 = PyArray_DIMS( tmp8 )[0];
6035 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
6036 }
6037 if (swig_obj[6]) {
6038 {
6039 // it must be a callable or None
6040 if ( swig_obj[6] == Py_None )
6041 {
6042 arg10 = NULL;
6043 }
6044 else
6045 {
6046 if ( !PyCallable_Check( (PyObject *) swig_obj[6] ) )
6047 {
6048 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
6049 return NULL;
6050 }
6051 arg10 = marshal_pltr( swig_obj[6] );
6052 }
6053 }
6054 }
6055 if (swig_obj[7]) {
6056 {
6057 if ( swig_obj[7] == Py_None )
6058 arg11 = NULL;
6059 else
6060 {
6061 arg11 = marshal_PLPointer( swig_obj[7], 0 );
6062 }
6063 }
6064 }
6065 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
6066 resultobj = SWIG_Py_Void();
6067 {
6068 Py_CLEAR( tmp1 );
6069 free( arg1 );
6070 }
6071 {
6072 Py_CLEAR( tmp8 );
6073 }
6074 {
6075 cleanup_pltr();
6076 }
6077 {
6079 }
6080 return resultobj;
6081fail:
6082 {
6083 Py_CLEAR( tmp1 );
6084 free( arg1 );
6085 }
6086 {
6087 Py_CLEAR( tmp8 );
6088 }
6089 {
6090 cleanup_pltr();
6091 }
6092 {
6094 }
6095 return NULL;
6096}
6097
6098
6099SWIGINTERN PyObject *_wrap_plctime(PyObject *self, PyObject *args) {
6100 PyObject *resultobj = 0;
6101 PLINT arg1 ;
6102 PLINT arg2 ;
6103 PLINT arg3 ;
6104 PLINT arg4 ;
6105 PLINT arg5 ;
6106 PLFLT arg6 ;
6107 PLFLT *arg7 = (PLFLT *) 0 ;
6108 int val1 ;
6109 int ecode1 = 0 ;
6110 int val2 ;
6111 int ecode2 = 0 ;
6112 int val3 ;
6113 int ecode3 = 0 ;
6114 int val4 ;
6115 int ecode4 = 0 ;
6116 int val5 ;
6117 int ecode5 = 0 ;
6118 double val6 ;
6119 int ecode6 = 0 ;
6120 PLFLT temp7 ;
6121 int res7 = SWIG_TMPOBJ ;
6122 PyObject *swig_obj[6] ;
6123
6124 arg7 = &temp7;
6125 (void)self;
6126 if (!SWIG_Python_UnpackTuple(args, "plctime", 6, 6, swig_obj)) SWIG_fail;
6127 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6128 if (!SWIG_IsOK(ecode1)) {
6129 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
6130 }
6131 arg1 = (PLINT)(val1);
6132 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6133 if (!SWIG_IsOK(ecode2)) {
6134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
6135 }
6136 arg2 = (PLINT)(val2);
6137 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
6138 if (!SWIG_IsOK(ecode3)) {
6139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
6140 }
6141 arg3 = (PLINT)(val3);
6142 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
6143 if (!SWIG_IsOK(ecode4)) {
6144 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
6145 }
6146 arg4 = (PLINT)(val4);
6147 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6148 if (!SWIG_IsOK(ecode5)) {
6149 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
6150 }
6151 arg5 = (PLINT)(val5);
6152 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
6153 if (!SWIG_IsOK(ecode6)) {
6154 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
6155 }
6156 arg6 = (PLFLT)(val6);
6157 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
6158 resultobj = SWIG_Py_Void();
6159 if (SWIG_IsTmpObj(res7)) {
6160 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
6161 } else {
6162 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6163 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
6164 }
6165 return resultobj;
6166fail:
6167 return NULL;
6168}
6169
6170
6171SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *self, PyObject *args) {
6172 PyObject *resultobj = 0;
6173 PLINT arg1 ;
6174 PLBOOL arg2 ;
6175 int val1 ;
6176 int ecode1 = 0 ;
6177 int val2 ;
6178 int ecode2 = 0 ;
6179 PyObject *swig_obj[2] ;
6180
6181 (void)self;
6182 if (!SWIG_Python_UnpackTuple(args, "plcpstrm", 2, 2, swig_obj)) SWIG_fail;
6183 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6184 if (!SWIG_IsOK(ecode1)) {
6185 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
6186 }
6187 arg1 = (PLINT)(val1);
6188 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6189 if (!SWIG_IsOK(ecode2)) {
6190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
6191 }
6192 arg2 = (PLBOOL)(val2);
6193 plcpstrm(arg1,arg2);
6194 resultobj = SWIG_Py_Void();
6195 return resultobj;
6196fail:
6197 return NULL;
6198}
6199
6200
6201SWIGINTERN PyObject *_wrap_plend(PyObject *self, PyObject *args) {
6202 PyObject *resultobj = 0;
6203
6204 (void)self;
6205 if (!SWIG_Python_UnpackTuple(args, "plend", 0, 0, 0)) SWIG_fail;
6206 plend();
6207 resultobj = SWIG_Py_Void();
6208 return resultobj;
6209fail:
6210 return NULL;
6211}
6212
6213
6214SWIGINTERN PyObject *_wrap_plend1(PyObject *self, PyObject *args) {
6215 PyObject *resultobj = 0;
6216
6217 (void)self;
6218 if (!SWIG_Python_UnpackTuple(args, "plend1", 0, 0, 0)) SWIG_fail;
6219 plend1();
6220 resultobj = SWIG_Py_Void();
6221 return resultobj;
6222fail:
6223 return NULL;
6224}
6225
6226
6227SWIGINTERN PyObject *_wrap_plenv(PyObject *self, PyObject *args) {
6228 PyObject *resultobj = 0;
6229 PLFLT arg1 ;
6230 PLFLT arg2 ;
6231 PLFLT arg3 ;
6232 PLFLT arg4 ;
6233 PLINT arg5 ;
6234 PLINT arg6 ;
6235 double val1 ;
6236 int ecode1 = 0 ;
6237 double val2 ;
6238 int ecode2 = 0 ;
6239 double val3 ;
6240 int ecode3 = 0 ;
6241 double val4 ;
6242 int ecode4 = 0 ;
6243 int val5 ;
6244 int ecode5 = 0 ;
6245 int val6 ;
6246 int ecode6 = 0 ;
6247 PyObject *swig_obj[6] ;
6248
6249 (void)self;
6250 if (!SWIG_Python_UnpackTuple(args, "plenv", 6, 6, swig_obj)) SWIG_fail;
6251 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6252 if (!SWIG_IsOK(ecode1)) {
6253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
6254 }
6255 arg1 = (PLFLT)(val1);
6256 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6257 if (!SWIG_IsOK(ecode2)) {
6258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
6259 }
6260 arg2 = (PLFLT)(val2);
6261 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6262 if (!SWIG_IsOK(ecode3)) {
6263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
6264 }
6265 arg3 = (PLFLT)(val3);
6266 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6267 if (!SWIG_IsOK(ecode4)) {
6268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
6269 }
6270 arg4 = (PLFLT)(val4);
6271 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6272 if (!SWIG_IsOK(ecode5)) {
6273 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
6274 }
6275 arg5 = (PLINT)(val5);
6276 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6277 if (!SWIG_IsOK(ecode6)) {
6278 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6279 }
6280 arg6 = (PLINT)(val6);
6281 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6282 resultobj = SWIG_Py_Void();
6283 return resultobj;
6284fail:
6285 return NULL;
6286}
6287
6288
6289SWIGINTERN PyObject *_wrap_plenv0(PyObject *self, PyObject *args) {
6290 PyObject *resultobj = 0;
6291 PLFLT arg1 ;
6292 PLFLT arg2 ;
6293 PLFLT arg3 ;
6294 PLFLT arg4 ;
6295 PLINT arg5 ;
6296 PLINT arg6 ;
6297 double val1 ;
6298 int ecode1 = 0 ;
6299 double val2 ;
6300 int ecode2 = 0 ;
6301 double val3 ;
6302 int ecode3 = 0 ;
6303 double val4 ;
6304 int ecode4 = 0 ;
6305 int val5 ;
6306 int ecode5 = 0 ;
6307 int val6 ;
6308 int ecode6 = 0 ;
6309 PyObject *swig_obj[6] ;
6310
6311 (void)self;
6312 if (!SWIG_Python_UnpackTuple(args, "plenv0", 6, 6, swig_obj)) SWIG_fail;
6313 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6314 if (!SWIG_IsOK(ecode1)) {
6315 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6316 }
6317 arg1 = (PLFLT)(val1);
6318 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6319 if (!SWIG_IsOK(ecode2)) {
6320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6321 }
6322 arg2 = (PLFLT)(val2);
6323 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6324 if (!SWIG_IsOK(ecode3)) {
6325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6326 }
6327 arg3 = (PLFLT)(val3);
6328 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6329 if (!SWIG_IsOK(ecode4)) {
6330 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6331 }
6332 arg4 = (PLFLT)(val4);
6333 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6334 if (!SWIG_IsOK(ecode5)) {
6335 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6336 }
6337 arg5 = (PLINT)(val5);
6338 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6339 if (!SWIG_IsOK(ecode6)) {
6340 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6341 }
6342 arg6 = (PLINT)(val6);
6343 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6344 resultobj = SWIG_Py_Void();
6345 return resultobj;
6346fail:
6347 return NULL;
6348}
6349
6350
6351SWIGINTERN PyObject *_wrap_pleop(PyObject *self, PyObject *args) {
6352 PyObject *resultobj = 0;
6353
6354 (void)self;
6355 if (!SWIG_Python_UnpackTuple(args, "pleop", 0, 0, 0)) SWIG_fail;
6356 pleop();
6357 resultobj = SWIG_Py_Void();
6358 return resultobj;
6359fail:
6360 return NULL;
6361}
6362
6363
6364SWIGINTERN PyObject *_wrap_plerrx(PyObject *self, PyObject *args) {
6365 PyObject *resultobj = 0;
6366 PLINT arg1 ;
6367 PLFLT *arg2 = (PLFLT *) 0 ;
6368 PLFLT *arg3 = (PLFLT *) 0 ;
6369 PLFLT *arg4 = (PLFLT *) 0 ;
6370 PyArrayObject *tmp1 = NULL ;
6371 PyArrayObject *tmp3 = NULL ;
6372 PyArrayObject *tmp4 = NULL ;
6373 PyObject *swig_obj[3] ;
6374
6375 (void)self;
6376 if (!SWIG_Python_UnpackTuple(args, "plerrx", 3, 3, swig_obj)) SWIG_fail;
6377 {
6378 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6379 if ( tmp1 == NULL )
6380 return NULL;
6381 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6382 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6383 }
6384 {
6385 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6386 if ( tmp3 == NULL )
6387 return NULL;
6388 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6389 {
6390 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6391 return NULL;
6392 }
6393 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6394 }
6395 {
6396 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6397 if ( tmp4 == NULL )
6398 return NULL;
6399 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6400 {
6401 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6402 return NULL;
6403 }
6404 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6405 }
6406 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6407 resultobj = SWIG_Py_Void();
6408 {
6409 Py_CLEAR( tmp1 );
6410 }
6411 {
6412 Py_CLEAR( tmp3 );
6413 }
6414 {
6415 Py_CLEAR( tmp4 );
6416 }
6417 return resultobj;
6418fail:
6419 {
6420 Py_CLEAR( tmp1 );
6421 }
6422 {
6423 Py_CLEAR( tmp3 );
6424 }
6425 {
6426 Py_CLEAR( tmp4 );
6427 }
6428 return NULL;
6429}
6430
6431
6432SWIGINTERN PyObject *_wrap_plerry(PyObject *self, PyObject *args) {
6433 PyObject *resultobj = 0;
6434 PLINT arg1 ;
6435 PLFLT *arg2 = (PLFLT *) 0 ;
6436 PLFLT *arg3 = (PLFLT *) 0 ;
6437 PLFLT *arg4 = (PLFLT *) 0 ;
6438 PyArrayObject *tmp1 = NULL ;
6439 PyArrayObject *tmp3 = NULL ;
6440 PyArrayObject *tmp4 = NULL ;
6441 PyObject *swig_obj[3] ;
6442
6443 (void)self;
6444 if (!SWIG_Python_UnpackTuple(args, "plerry", 3, 3, swig_obj)) SWIG_fail;
6445 {
6446 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6447 if ( tmp1 == NULL )
6448 return NULL;
6449 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6450 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6451 }
6452 {
6453 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6454 if ( tmp3 == NULL )
6455 return NULL;
6456 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6457 {
6458 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6459 return NULL;
6460 }
6461 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6462 }
6463 {
6464 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6465 if ( tmp4 == NULL )
6466 return NULL;
6467 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6468 {
6469 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6470 return NULL;
6471 }
6472 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6473 }
6474 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6475 resultobj = SWIG_Py_Void();
6476 {
6477 Py_CLEAR( tmp1 );
6478 }
6479 {
6480 Py_CLEAR( tmp3 );
6481 }
6482 {
6483 Py_CLEAR( tmp4 );
6484 }
6485 return resultobj;
6486fail:
6487 {
6488 Py_CLEAR( tmp1 );
6489 }
6490 {
6491 Py_CLEAR( tmp3 );
6492 }
6493 {
6494 Py_CLEAR( tmp4 );
6495 }
6496 return NULL;
6497}
6498
6499
6500SWIGINTERN PyObject *_wrap_plfamadv(PyObject *self, PyObject *args) {
6501 PyObject *resultobj = 0;
6502
6503 (void)self;
6504 if (!SWIG_Python_UnpackTuple(args, "plfamadv", 0, 0, 0)) SWIG_fail;
6505 plfamadv();
6506 resultobj = SWIG_Py_Void();
6507 return resultobj;
6508fail:
6509 return NULL;
6510}
6511
6512
6513SWIGINTERN PyObject *_wrap_plfill(PyObject *self, PyObject *args) {
6514 PyObject *resultobj = 0;
6515 PLINT arg1 ;
6516 PLFLT *arg2 = (PLFLT *) 0 ;
6517 PLFLT *arg3 = (PLFLT *) 0 ;
6518 PyArrayObject *tmp1 = NULL ;
6519 PyArrayObject *tmp3 = NULL ;
6520 PyObject *swig_obj[2] ;
6521
6522 (void)self;
6523 if (!SWIG_Python_UnpackTuple(args, "plfill", 2, 2, swig_obj)) SWIG_fail;
6524 {
6525 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6526 if ( tmp1 == NULL )
6527 return NULL;
6528 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6529 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6530 }
6531 {
6532 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6533 if ( tmp3 == NULL )
6534 return NULL;
6535 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6536 {
6537 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6538 return NULL;
6539 }
6540 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6541 }
6542 plfill(arg1,(double const *)arg2,(double const *)arg3);
6543 resultobj = SWIG_Py_Void();
6544 {
6545 Py_CLEAR( tmp1 );
6546 }
6547 {
6548 Py_CLEAR( tmp3 );
6549 }
6550 return resultobj;
6551fail:
6552 {
6553 Py_CLEAR( tmp1 );
6554 }
6555 {
6556 Py_CLEAR( tmp3 );
6557 }
6558 return NULL;
6559}
6560
6561
6562SWIGINTERN PyObject *_wrap_plfill3(PyObject *self, PyObject *args) {
6563 PyObject *resultobj = 0;
6564 PLINT arg1 ;
6565 PLFLT *arg2 = (PLFLT *) 0 ;
6566 PLFLT *arg3 = (PLFLT *) 0 ;
6567 PLFLT *arg4 = (PLFLT *) 0 ;
6568 PyArrayObject *tmp1 = NULL ;
6569 PyArrayObject *tmp3 = NULL ;
6570 PyArrayObject *tmp4 = NULL ;
6571 PyObject *swig_obj[3] ;
6572
6573 (void)self;
6574 if (!SWIG_Python_UnpackTuple(args, "plfill3", 3, 3, swig_obj)) SWIG_fail;
6575 {
6576 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6577 if ( tmp1 == NULL )
6578 return NULL;
6579 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6580 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6581 }
6582 {
6583 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6584 if ( tmp3 == NULL )
6585 return NULL;
6586 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6587 {
6588 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6589 return NULL;
6590 }
6591 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6592 }
6593 {
6594 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6595 if ( tmp4 == NULL )
6596 return NULL;
6597 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6598 {
6599 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6600 return NULL;
6601 }
6602 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6603 }
6604 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6605 resultobj = SWIG_Py_Void();
6606 {
6607 Py_CLEAR( tmp1 );
6608 }
6609 {
6610 Py_CLEAR( tmp3 );
6611 }
6612 {
6613 Py_CLEAR( tmp4 );
6614 }
6615 return resultobj;
6616fail:
6617 {
6618 Py_CLEAR( tmp1 );
6619 }
6620 {
6621 Py_CLEAR( tmp3 );
6622 }
6623 {
6624 Py_CLEAR( tmp4 );
6625 }
6626 return NULL;
6627}
6628
6629
6630SWIGINTERN PyObject *_wrap_plgradient(PyObject *self, PyObject *args) {
6631 PyObject *resultobj = 0;
6632 PLINT arg1 ;
6633 PLFLT *arg2 = (PLFLT *) 0 ;
6634 PLFLT *arg3 = (PLFLT *) 0 ;
6635 PLFLT arg4 ;
6636 PyArrayObject *tmp1 = NULL ;
6637 PyArrayObject *tmp3 = NULL ;
6638 double val4 ;
6639 int ecode4 = 0 ;
6640 PyObject *swig_obj[3] ;
6641
6642 (void)self;
6643 if (!SWIG_Python_UnpackTuple(args, "plgradient", 3, 3, swig_obj)) SWIG_fail;
6644 {
6645 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6646 if ( tmp1 == NULL )
6647 return NULL;
6648 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6649 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6650 }
6651 {
6652 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6653 if ( tmp3 == NULL )
6654 return NULL;
6655 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6656 {
6657 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6658 return NULL;
6659 }
6660 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6661 }
6662 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
6663 if (!SWIG_IsOK(ecode4)) {
6664 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6665 }
6666 arg4 = (PLFLT)(val4);
6667 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6668 resultobj = SWIG_Py_Void();
6669 {
6670 Py_CLEAR( tmp1 );
6671 }
6672 {
6673 Py_CLEAR( tmp3 );
6674 }
6675 return resultobj;
6676fail:
6677 {
6678 Py_CLEAR( tmp1 );
6679 }
6680 {
6681 Py_CLEAR( tmp3 );
6682 }
6683 return NULL;
6684}
6685
6686
6687SWIGINTERN PyObject *_wrap_plflush(PyObject *self, PyObject *args) {
6688 PyObject *resultobj = 0;
6689
6690 (void)self;
6691 if (!SWIG_Python_UnpackTuple(args, "plflush", 0, 0, 0)) SWIG_fail;
6692 plflush();
6693 resultobj = SWIG_Py_Void();
6694 return resultobj;
6695fail:
6696 return NULL;
6697}
6698
6699
6700SWIGINTERN PyObject *_wrap_plfont(PyObject *self, PyObject *args) {
6701 PyObject *resultobj = 0;
6702 PLINT arg1 ;
6703 int val1 ;
6704 int ecode1 = 0 ;
6705 PyObject *swig_obj[1] ;
6706
6707 (void)self;
6708 if (!args) SWIG_fail;
6709 swig_obj[0] = args;
6710 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6711 if (!SWIG_IsOK(ecode1)) {
6712 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6713 }
6714 arg1 = (PLINT)(val1);
6715 plfont(arg1);
6716 resultobj = SWIG_Py_Void();
6717 return resultobj;
6718fail:
6719 return NULL;
6720}
6721
6722
6723SWIGINTERN PyObject *_wrap_plfontld(PyObject *self, PyObject *args) {
6724 PyObject *resultobj = 0;
6725 PLINT arg1 ;
6726 int val1 ;
6727 int ecode1 = 0 ;
6728 PyObject *swig_obj[1] ;
6729
6730 (void)self;
6731 if (!args) SWIG_fail;
6732 swig_obj[0] = args;
6733 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6734 if (!SWIG_IsOK(ecode1)) {
6735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6736 }
6737 arg1 = (PLINT)(val1);
6738 plfontld(arg1);
6739 resultobj = SWIG_Py_Void();
6740 return resultobj;
6741fail:
6742 return NULL;
6743}
6744
6745
6746SWIGINTERN PyObject *_wrap_plgchr(PyObject *self, PyObject *args) {
6747 PyObject *resultobj = 0;
6748 PLFLT *arg1 = (PLFLT *) 0 ;
6749 PLFLT *arg2 = (PLFLT *) 0 ;
6750 PLFLT temp1 ;
6751 int res1 = SWIG_TMPOBJ ;
6752 PLFLT temp2 ;
6753 int res2 = SWIG_TMPOBJ ;
6754
6755 arg1 = &temp1;
6756 arg2 = &temp2;
6757 (void)self;
6758 if (!SWIG_Python_UnpackTuple(args, "plgchr", 0, 0, 0)) SWIG_fail;
6759 plgchr(arg1,arg2);
6760 resultobj = SWIG_Py_Void();
6761 if (SWIG_IsTmpObj(res1)) {
6762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
6763 } else {
6764 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
6766 }
6767 if (SWIG_IsTmpObj(res2)) {
6768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
6769 } else {
6770 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6771 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
6772 }
6773 return resultobj;
6774fail:
6775 return NULL;
6776}
6777
6778
6779SWIGINTERN PyObject *_wrap_plgcol0(PyObject *self, PyObject *args) {
6780 PyObject *resultobj = 0;
6781 PLINT arg1 ;
6782 PLINT *arg2 = (PLINT *) 0 ;
6783 PLINT *arg3 = (PLINT *) 0 ;
6784 PLINT *arg4 = (PLINT *) 0 ;
6785 int val1 ;
6786 int ecode1 = 0 ;
6787 PLINT temp2 ;
6788 int res2 = SWIG_TMPOBJ ;
6789 PLINT temp3 ;
6790 int res3 = SWIG_TMPOBJ ;
6791 PLINT temp4 ;
6792 int res4 = SWIG_TMPOBJ ;
6793 PyObject *swig_obj[1] ;
6794
6795 arg2 = &temp2;
6796 arg3 = &temp3;
6797 arg4 = &temp4;
6798 (void)self;
6799 if (!args) SWIG_fail;
6800 swig_obj[0] = args;
6801 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6802 if (!SWIG_IsOK(ecode1)) {
6803 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6804 }
6805 arg1 = (PLINT)(val1);
6806 plgcol0(arg1,arg2,arg3,arg4);
6807 resultobj = SWIG_Py_Void();
6808 if (SWIG_IsTmpObj(res2)) {
6809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6810 } else {
6811 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6813 }
6814 if (SWIG_IsTmpObj(res3)) {
6815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6816 } else {
6817 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6819 }
6820 if (SWIG_IsTmpObj(res4)) {
6821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6822 } else {
6823 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6825 }
6826 return resultobj;
6827fail:
6828 return NULL;
6829}
6830
6831
6832SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *self, PyObject *args) {
6833 PyObject *resultobj = 0;
6834 PLINT arg1 ;
6835 PLINT *arg2 = (PLINT *) 0 ;
6836 PLINT *arg3 = (PLINT *) 0 ;
6837 PLINT *arg4 = (PLINT *) 0 ;
6838 PLFLT *arg5 = (PLFLT *) 0 ;
6839 int val1 ;
6840 int ecode1 = 0 ;
6841 PLINT temp2 ;
6842 int res2 = SWIG_TMPOBJ ;
6843 PLINT temp3 ;
6844 int res3 = SWIG_TMPOBJ ;
6845 PLINT temp4 ;
6846 int res4 = SWIG_TMPOBJ ;
6847 PLFLT temp5 ;
6848 int res5 = SWIG_TMPOBJ ;
6849 PyObject *swig_obj[1] ;
6850
6851 arg2 = &temp2;
6852 arg3 = &temp3;
6853 arg4 = &temp4;
6854 arg5 = &temp5;
6855 (void)self;
6856 if (!args) SWIG_fail;
6857 swig_obj[0] = args;
6858 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6859 if (!SWIG_IsOK(ecode1)) {
6860 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6861 }
6862 arg1 = (PLINT)(val1);
6863 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6864 resultobj = SWIG_Py_Void();
6865 if (SWIG_IsTmpObj(res2)) {
6866 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6867 } else {
6868 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6869 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6870 }
6871 if (SWIG_IsTmpObj(res3)) {
6872 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6873 } else {
6874 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6875 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6876 }
6877 if (SWIG_IsTmpObj(res4)) {
6878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6879 } else {
6880 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6882 }
6883 if (SWIG_IsTmpObj(res5)) {
6884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
6885 } else {
6886 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
6888 }
6889 return resultobj;
6890fail:
6891 return NULL;
6892}
6893
6894
6895SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *self, PyObject *args) {
6896 PyObject *resultobj = 0;
6897 PLINT *arg1 = (PLINT *) 0 ;
6898 PLINT *arg2 = (PLINT *) 0 ;
6899 PLINT *arg3 = (PLINT *) 0 ;
6900 PLINT temp1 ;
6901 int res1 = SWIG_TMPOBJ ;
6902 PLINT temp2 ;
6903 int res2 = SWIG_TMPOBJ ;
6904 PLINT temp3 ;
6905 int res3 = SWIG_TMPOBJ ;
6906
6907 arg1 = &temp1;
6908 arg2 = &temp2;
6909 arg3 = &temp3;
6910 (void)self;
6911 if (!SWIG_Python_UnpackTuple(args, "plgcolbg", 0, 0, 0)) SWIG_fail;
6912 plgcolbg(arg1,arg2,arg3);
6913 resultobj = SWIG_Py_Void();
6914 if (SWIG_IsTmpObj(res1)) {
6915 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6916 } else {
6917 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6918 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6919 }
6920 if (SWIG_IsTmpObj(res2)) {
6921 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6922 } else {
6923 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6925 }
6926 if (SWIG_IsTmpObj(res3)) {
6927 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6928 } else {
6929 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6930 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6931 }
6932 return resultobj;
6933fail:
6934 return NULL;
6935}
6936
6937
6938SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *self, PyObject *args) {
6939 PyObject *resultobj = 0;
6940 PLINT *arg1 = (PLINT *) 0 ;
6941 PLINT *arg2 = (PLINT *) 0 ;
6942 PLINT *arg3 = (PLINT *) 0 ;
6943 PLFLT *arg4 = (PLFLT *) 0 ;
6944 PLINT temp1 ;
6945 int res1 = SWIG_TMPOBJ ;
6946 PLINT temp2 ;
6947 int res2 = SWIG_TMPOBJ ;
6948 PLINT temp3 ;
6949 int res3 = SWIG_TMPOBJ ;
6950 PLFLT temp4 ;
6951 int res4 = SWIG_TMPOBJ ;
6952
6953 arg1 = &temp1;
6954 arg2 = &temp2;
6955 arg3 = &temp3;
6956 arg4 = &temp4;
6957 (void)self;
6958 if (!SWIG_Python_UnpackTuple(args, "plgcolbga", 0, 0, 0)) SWIG_fail;
6959 plgcolbga(arg1,arg2,arg3,arg4);
6960 resultobj = SWIG_Py_Void();
6961 if (SWIG_IsTmpObj(res1)) {
6962 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6963 } else {
6964 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6965 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6966 }
6967 if (SWIG_IsTmpObj(res2)) {
6968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6969 } else {
6970 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6972 }
6973 if (SWIG_IsTmpObj(res3)) {
6974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6975 } else {
6976 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6978 }
6979 if (SWIG_IsTmpObj(res4)) {
6980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
6981 } else {
6982 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
6984 }
6985 return resultobj;
6986fail:
6987 return NULL;
6988}
6989
6990
6991SWIGINTERN PyObject *_wrap_plgcompression(PyObject *self, PyObject *args) {
6992 PyObject *resultobj = 0;
6993 PLINT *arg1 = (PLINT *) 0 ;
6994 PLINT temp1 ;
6995 int res1 = SWIG_TMPOBJ ;
6996
6997 arg1 = &temp1;
6998 (void)self;
6999 if (!SWIG_Python_UnpackTuple(args, "plgcompression", 0, 0, 0)) SWIG_fail;
7000 plgcompression(arg1);
7001 resultobj = SWIG_Py_Void();
7002 if (SWIG_IsTmpObj(res1)) {
7003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7004 } else {
7005 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7007 }
7008 return resultobj;
7009fail:
7010 return NULL;
7011}
7012
7013
7014SWIGINTERN PyObject *_wrap_plgdev(PyObject *self, PyObject *args) {
7015 PyObject *resultobj = 0;
7016 char *arg1 = (char *) 0 ;
7017 char buff1[1000] ;
7018
7019 {
7020 arg1 = buff1;
7021 }
7022 (void)self;
7023 if (!SWIG_Python_UnpackTuple(args, "plgdev", 0, 0, 0)) SWIG_fail;
7024 plgdev(arg1);
7025 resultobj = SWIG_Py_Void();
7026 {
7027 PyObject *o = PyString_FromString( arg1 );
7028 resultobj = t_output_helper( resultobj, o );
7029 }
7030 return resultobj;
7031fail:
7032 return NULL;
7033}
7034
7035
7036SWIGINTERN PyObject *_wrap_plgdidev(PyObject *self, PyObject *args) {
7037 PyObject *resultobj = 0;
7038 PLFLT *arg1 = (PLFLT *) 0 ;
7039 PLFLT *arg2 = (PLFLT *) 0 ;
7040 PLFLT *arg3 = (PLFLT *) 0 ;
7041 PLFLT *arg4 = (PLFLT *) 0 ;
7042 PLFLT temp1 ;
7043 int res1 = SWIG_TMPOBJ ;
7044 PLFLT temp2 ;
7045 int res2 = SWIG_TMPOBJ ;
7046 PLFLT temp3 ;
7047 int res3 = SWIG_TMPOBJ ;
7048 PLFLT temp4 ;
7049 int res4 = SWIG_TMPOBJ ;
7050
7051 arg1 = &temp1;
7052 arg2 = &temp2;
7053 arg3 = &temp3;
7054 arg4 = &temp4;
7055 (void)self;
7056 if (!SWIG_Python_UnpackTuple(args, "plgdidev", 0, 0, 0)) SWIG_fail;
7057 plgdidev(arg1,arg2,arg3,arg4);
7058 resultobj = SWIG_Py_Void();
7059 if (SWIG_IsTmpObj(res1)) {
7060 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7061 } else {
7062 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7063 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7064 }
7065 if (SWIG_IsTmpObj(res2)) {
7066 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7067 } else {
7068 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7069 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7070 }
7071 if (SWIG_IsTmpObj(res3)) {
7072 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7073 } else {
7074 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7076 }
7077 if (SWIG_IsTmpObj(res4)) {
7078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7079 } else {
7080 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7081 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7082 }
7083 return resultobj;
7084fail:
7085 return NULL;
7086}
7087
7088
7089SWIGINTERN PyObject *_wrap_plgdiori(PyObject *self, PyObject *args) {
7090 PyObject *resultobj = 0;
7091 PLFLT *arg1 = (PLFLT *) 0 ;
7092 PLFLT temp1 ;
7093 int res1 = SWIG_TMPOBJ ;
7094
7095 arg1 = &temp1;
7096 (void)self;
7097 if (!SWIG_Python_UnpackTuple(args, "plgdiori", 0, 0, 0)) SWIG_fail;
7098 plgdiori(arg1);
7099 resultobj = SWIG_Py_Void();
7100 if (SWIG_IsTmpObj(res1)) {
7101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7102 } else {
7103 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7105 }
7106 return resultobj;
7107fail:
7108 return NULL;
7109}
7110
7111
7112SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *self, PyObject *args) {
7113 PyObject *resultobj = 0;
7114 PLFLT *arg1 = (PLFLT *) 0 ;
7115 PLFLT *arg2 = (PLFLT *) 0 ;
7116 PLFLT *arg3 = (PLFLT *) 0 ;
7117 PLFLT *arg4 = (PLFLT *) 0 ;
7118 PLFLT temp1 ;
7119 int res1 = SWIG_TMPOBJ ;
7120 PLFLT temp2 ;
7121 int res2 = SWIG_TMPOBJ ;
7122 PLFLT temp3 ;
7123 int res3 = SWIG_TMPOBJ ;
7124 PLFLT temp4 ;
7125 int res4 = SWIG_TMPOBJ ;
7126
7127 arg1 = &temp1;
7128 arg2 = &temp2;
7129 arg3 = &temp3;
7130 arg4 = &temp4;
7131 (void)self;
7132 if (!SWIG_Python_UnpackTuple(args, "plgdiplt", 0, 0, 0)) SWIG_fail;
7133 plgdiplt(arg1,arg2,arg3,arg4);
7134 resultobj = SWIG_Py_Void();
7135 if (SWIG_IsTmpObj(res1)) {
7136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7137 } else {
7138 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7139 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7140 }
7141 if (SWIG_IsTmpObj(res2)) {
7142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7143 } else {
7144 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7146 }
7147 if (SWIG_IsTmpObj(res3)) {
7148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7149 } else {
7150 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7152 }
7153 if (SWIG_IsTmpObj(res4)) {
7154 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7155 } else {
7156 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7157 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7158 }
7159 return resultobj;
7160fail:
7161 return NULL;
7162}
7163
7164
7165SWIGINTERN PyObject *_wrap_plgfam(PyObject *self, PyObject *args) {
7166 PyObject *resultobj = 0;
7167 PLINT *arg1 = (PLINT *) 0 ;
7168 PLINT *arg2 = (PLINT *) 0 ;
7169 PLINT *arg3 = (PLINT *) 0 ;
7170 PLINT temp1 ;
7171 int res1 = SWIG_TMPOBJ ;
7172 PLINT temp2 ;
7173 int res2 = SWIG_TMPOBJ ;
7174 PLINT temp3 ;
7175 int res3 = SWIG_TMPOBJ ;
7176
7177 arg1 = &temp1;
7178 arg2 = &temp2;
7179 arg3 = &temp3;
7180 (void)self;
7181 if (!SWIG_Python_UnpackTuple(args, "plgfam", 0, 0, 0)) SWIG_fail;
7182 plgfam(arg1,arg2,arg3);
7183 resultobj = SWIG_Py_Void();
7184 if (SWIG_IsTmpObj(res1)) {
7185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7186 } else {
7187 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7189 }
7190 if (SWIG_IsTmpObj(res2)) {
7191 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7192 } else {
7193 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7194 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7195 }
7196 if (SWIG_IsTmpObj(res3)) {
7197 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7198 } else {
7199 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7200 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7201 }
7202 return resultobj;
7203fail:
7204 return NULL;
7205}
7206
7207
7208SWIGINTERN PyObject *_wrap_plgfci(PyObject *self, PyObject *args) {
7209 PyObject *resultobj = 0;
7210 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
7211 PLUNICODE temp1 ;
7212 int res1 = SWIG_TMPOBJ ;
7213
7214 arg1 = &temp1;
7215 (void)self;
7216 if (!SWIG_Python_UnpackTuple(args, "plgfci", 0, 0, 0)) SWIG_fail;
7217 plgfci(arg1);
7218 resultobj = SWIG_Py_Void();
7219 if (SWIG_IsTmpObj(res1)) {
7220 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)));
7221 } else {
7222 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7223 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
7224 }
7225 return resultobj;
7226fail:
7227 return NULL;
7228}
7229
7230
7231SWIGINTERN PyObject *_wrap_plgfnam(PyObject *self, PyObject *args) {
7232 PyObject *resultobj = 0;
7233 char *arg1 = (char *) 0 ;
7234 char buff1[1000] ;
7235
7236 {
7237 arg1 = buff1;
7238 }
7239 (void)self;
7240 if (!SWIG_Python_UnpackTuple(args, "plgfnam", 0, 0, 0)) SWIG_fail;
7241 plgfnam(arg1);
7242 resultobj = SWIG_Py_Void();
7243 {
7244 PyObject *o = PyString_FromString( arg1 );
7245 resultobj = t_output_helper( resultobj, o );
7246 }
7247 return resultobj;
7248fail:
7249 return NULL;
7250}
7251
7252
7253SWIGINTERN PyObject *_wrap_plgfont(PyObject *self, PyObject *args) {
7254 PyObject *resultobj = 0;
7255 PLINT *arg1 = (PLINT *) 0 ;
7256 PLINT *arg2 = (PLINT *) 0 ;
7257 PLINT *arg3 = (PLINT *) 0 ;
7258 PLINT temp1 ;
7259 int res1 = SWIG_TMPOBJ ;
7260 PLINT temp2 ;
7261 int res2 = SWIG_TMPOBJ ;
7262 PLINT temp3 ;
7263 int res3 = SWIG_TMPOBJ ;
7264
7265 arg1 = &temp1;
7266 arg2 = &temp2;
7267 arg3 = &temp3;
7268 (void)self;
7269 if (!SWIG_Python_UnpackTuple(args, "plgfont", 0, 0, 0)) SWIG_fail;
7270 plgfont(arg1,arg2,arg3);
7271 resultobj = SWIG_Py_Void();
7272 if (SWIG_IsTmpObj(res1)) {
7273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7274 } else {
7275 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7277 }
7278 if (SWIG_IsTmpObj(res2)) {
7279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7280 } else {
7281 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7283 }
7284 if (SWIG_IsTmpObj(res3)) {
7285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7286 } else {
7287 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7289 }
7290 return resultobj;
7291fail:
7292 return NULL;
7293}
7294
7295
7296SWIGINTERN PyObject *_wrap_plglevel(PyObject *self, PyObject *args) {
7297 PyObject *resultobj = 0;
7298 PLINT *arg1 = (PLINT *) 0 ;
7299 PLINT temp1 ;
7300 int res1 = SWIG_TMPOBJ ;
7301
7302 arg1 = &temp1;
7303 (void)self;
7304 if (!SWIG_Python_UnpackTuple(args, "plglevel", 0, 0, 0)) SWIG_fail;
7305 plglevel(arg1);
7306 resultobj = SWIG_Py_Void();
7307 if (SWIG_IsTmpObj(res1)) {
7308 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7309 } else {
7310 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7311 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7312 }
7313 return resultobj;
7314fail:
7315 return NULL;
7316}
7317
7318
7319SWIGINTERN PyObject *_wrap_plgpage(PyObject *self, PyObject *args) {
7320 PyObject *resultobj = 0;
7321 PLFLT *arg1 = (PLFLT *) 0 ;
7322 PLFLT *arg2 = (PLFLT *) 0 ;
7323 PLINT *arg3 = (PLINT *) 0 ;
7324 PLINT *arg4 = (PLINT *) 0 ;
7325 PLINT *arg5 = (PLINT *) 0 ;
7326 PLINT *arg6 = (PLINT *) 0 ;
7327 PLFLT temp1 ;
7328 int res1 = SWIG_TMPOBJ ;
7329 PLFLT temp2 ;
7330 int res2 = SWIG_TMPOBJ ;
7331 PLINT temp3 ;
7332 int res3 = SWIG_TMPOBJ ;
7333 PLINT temp4 ;
7334 int res4 = SWIG_TMPOBJ ;
7335 PLINT temp5 ;
7336 int res5 = SWIG_TMPOBJ ;
7337 PLINT temp6 ;
7338 int res6 = SWIG_TMPOBJ ;
7339
7340 arg1 = &temp1;
7341 arg2 = &temp2;
7342 arg3 = &temp3;
7343 arg4 = &temp4;
7344 arg5 = &temp5;
7345 arg6 = &temp6;
7346 (void)self;
7347 if (!SWIG_Python_UnpackTuple(args, "plgpage", 0, 0, 0)) SWIG_fail;
7348 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7349 resultobj = SWIG_Py_Void();
7350 if (SWIG_IsTmpObj(res1)) {
7351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7352 } else {
7353 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7355 }
7356 if (SWIG_IsTmpObj(res2)) {
7357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7358 } else {
7359 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7361 }
7362 if (SWIG_IsTmpObj(res3)) {
7363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7364 } else {
7365 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7366 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7367 }
7368 if (SWIG_IsTmpObj(res4)) {
7369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
7370 } else {
7371 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7373 }
7374 if (SWIG_IsTmpObj(res5)) {
7375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
7376 } else {
7377 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
7379 }
7380 if (SWIG_IsTmpObj(res6)) {
7381 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
7382 } else {
7383 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
7385 }
7386 return resultobj;
7387fail:
7388 return NULL;
7389}
7390
7391
7392SWIGINTERN PyObject *_wrap_plgra(PyObject *self, PyObject *args) {
7393 PyObject *resultobj = 0;
7394
7395 (void)self;
7396 if (!SWIG_Python_UnpackTuple(args, "plgra", 0, 0, 0)) SWIG_fail;
7397 plgra();
7398 resultobj = SWIG_Py_Void();
7399 return resultobj;
7400fail:
7401 return NULL;
7402}
7403
7404
7405SWIGINTERN PyObject *_wrap_plgriddata(PyObject *self, PyObject *args) {
7406 PyObject *resultobj = 0;
7407 PLFLT *arg1 = (PLFLT *) 0 ;
7408 PLFLT *arg2 = (PLFLT *) 0 ;
7409 PLFLT *arg3 = (PLFLT *) 0 ;
7410 PLINT arg4 ;
7411 PLFLT *arg5 = (PLFLT *) 0 ;
7412 PLINT arg6 ;
7413 PLFLT *arg7 = (PLFLT *) 0 ;
7414 PLINT arg8 ;
7415 PLFLT **arg9 = (PLFLT **) 0 ;
7416 PLINT arg10 ;
7417 PLFLT arg11 ;
7418 PyArrayObject *tmp1 = NULL ;
7419 PyArrayObject *tmp2 = NULL ;
7420 PyArrayObject *tmp3 = NULL ;
7421 PyArrayObject *tmp5 = NULL ;
7422 PyArrayObject *tmp7 = NULL ;
7423 PyObject *array7 = NULL ;
7424 int val10 ;
7425 int ecode10 = 0 ;
7426 double val11 ;
7427 int ecode11 = 0 ;
7428 PyObject *swig_obj[7] ;
7429
7430 (void)self;
7431 if (!SWIG_Python_UnpackTuple(args, "plgriddata", 7, 7, swig_obj)) SWIG_fail;
7432 {
7433 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7434 if ( tmp1 == NULL )
7435 return NULL;
7436 Alen = PyArray_DIMS( tmp1 )[0];
7437 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7438 }
7439 {
7440 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
7441 if ( tmp2 == NULL )
7442 return NULL;
7443 if ( PyArray_DIMS( tmp2 )[0] != Alen )
7444 {
7445 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7446 return NULL;
7447 }
7448 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7449 }
7450 {
7451 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
7452 if ( tmp3 == NULL )
7453 return NULL;
7454 if ( PyArray_DIMS( tmp3 )[0] != Alen )
7455 {
7456 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7457 return NULL;
7458 }
7459 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7460 arg4 = PyArray_DIMS( tmp3 )[0];
7461 }
7462 {
7463 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
7464 if ( tmp5 == NULL )
7465 return NULL;
7466 Xlen = PyArray_DIMS( tmp5 )[0];
7467 arg6 = Xlen;
7468 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7469 }
7470 {
7471 int i, size;
7472 npy_intp dims[2];
7473 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
7474 if ( tmp7 == NULL )
7475 return NULL;
7476 Ylen = PyArray_DIMS( tmp7 )[0];
7477 arg8 = Ylen;
7478 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7479 // Make created 2D array7 have dimensions from prior ArrayX in the argument
7480 // list and this ArrayY.
7481 dims[0] = Xlen;
7482 dims[1] = Ylen;
7483 array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
7484 if ( !array7 )
7485 return NULL;
7486 size = Ylen;
7487 arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
7488 for ( i = 0; i < Xlen; i++ )
7489 arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7490 }
7491 ecode10 = SWIG_AsVal_int(swig_obj[5], &val10);
7492 if (!SWIG_IsOK(ecode10)) {
7493 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7494 }
7495 arg10 = (PLINT)(val10);
7496 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
7497 if (!SWIG_IsOK(ecode11)) {
7498 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7499 }
7500 arg11 = (PLFLT)(val11);
7501 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7502 resultobj = SWIG_Py_Void();
7503 {
7504 resultobj = SWIG_Python_AppendOutput( resultobj, array7 );
7505 }
7506 {
7507 Py_CLEAR( tmp1 );
7508 }
7509 {
7510 Py_CLEAR( tmp2 );
7511 }
7512 {
7513 Py_CLEAR( tmp3 );
7514 }
7515 {
7516 Py_CLEAR( tmp5 );
7517 }
7518 {
7519 Py_CLEAR( tmp7 );
7520 free( arg9 );
7521 }
7522 return resultobj;
7523fail:
7524 {
7525 Py_CLEAR( tmp1 );
7526 }
7527 {
7528 Py_CLEAR( tmp2 );
7529 }
7530 {
7531 Py_CLEAR( tmp3 );
7532 }
7533 {
7534 Py_CLEAR( tmp5 );
7535 }
7536 {
7537 Py_CLEAR( tmp7 );
7538 free( arg9 );
7539 }
7540 return NULL;
7541}
7542
7543
7544SWIGINTERN PyObject *_wrap_plgspa(PyObject *self, PyObject *args) {
7545 PyObject *resultobj = 0;
7546 PLFLT *arg1 = (PLFLT *) 0 ;
7547 PLFLT *arg2 = (PLFLT *) 0 ;
7548 PLFLT *arg3 = (PLFLT *) 0 ;
7549 PLFLT *arg4 = (PLFLT *) 0 ;
7550 PLFLT temp1 ;
7551 int res1 = SWIG_TMPOBJ ;
7552 PLFLT temp2 ;
7553 int res2 = SWIG_TMPOBJ ;
7554 PLFLT temp3 ;
7555 int res3 = SWIG_TMPOBJ ;
7556 PLFLT temp4 ;
7557 int res4 = SWIG_TMPOBJ ;
7558
7559 arg1 = &temp1;
7560 arg2 = &temp2;
7561 arg3 = &temp3;
7562 arg4 = &temp4;
7563 (void)self;
7564 if (!SWIG_Python_UnpackTuple(args, "plgspa", 0, 0, 0)) SWIG_fail;
7565 plgspa(arg1,arg2,arg3,arg4);
7566 resultobj = SWIG_Py_Void();
7567 if (SWIG_IsTmpObj(res1)) {
7568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7569 } else {
7570 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7572 }
7573 if (SWIG_IsTmpObj(res2)) {
7574 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7575 } else {
7576 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7577 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7578 }
7579 if (SWIG_IsTmpObj(res3)) {
7580 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7581 } else {
7582 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7583 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7584 }
7585 if (SWIG_IsTmpObj(res4)) {
7586 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7587 } else {
7588 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7589 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7590 }
7591 return resultobj;
7592fail:
7593 return NULL;
7594}
7595
7596
7597SWIGINTERN PyObject *_wrap_plgstrm(PyObject *self, PyObject *args) {
7598 PyObject *resultobj = 0;
7599 PLINT *arg1 = (PLINT *) 0 ;
7600 PLINT temp1 ;
7601 int res1 = SWIG_TMPOBJ ;
7602
7603 arg1 = &temp1;
7604 (void)self;
7605 if (!SWIG_Python_UnpackTuple(args, "plgstrm", 0, 0, 0)) SWIG_fail;
7606 plgstrm(arg1);
7607 resultobj = SWIG_Py_Void();
7608 if (SWIG_IsTmpObj(res1)) {
7609 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7610 } else {
7611 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7613 }
7614 return resultobj;
7615fail:
7616 return NULL;
7617}
7618
7619
7620SWIGINTERN PyObject *_wrap_plgver(PyObject *self, PyObject *args) {
7621 PyObject *resultobj = 0;
7622 char *arg1 = (char *) 0 ;
7623 char buff1[1000] ;
7624
7625 {
7626 arg1 = buff1;
7627 }
7628 (void)self;
7629 if (!SWIG_Python_UnpackTuple(args, "plgver", 0, 0, 0)) SWIG_fail;
7630 plgver(arg1);
7631 resultobj = SWIG_Py_Void();
7632 {
7633 PyObject *o = PyString_FromString( arg1 );
7634 resultobj = t_output_helper( resultobj, o );
7635 }
7636 return resultobj;
7637fail:
7638 return NULL;
7639}
7640
7641
7642SWIGINTERN PyObject *_wrap_plgvpd(PyObject *self, PyObject *args) {
7643 PyObject *resultobj = 0;
7644 PLFLT *arg1 = (PLFLT *) 0 ;
7645 PLFLT *arg2 = (PLFLT *) 0 ;
7646 PLFLT *arg3 = (PLFLT *) 0 ;
7647 PLFLT *arg4 = (PLFLT *) 0 ;
7648 PLFLT temp1 ;
7649 int res1 = SWIG_TMPOBJ ;
7650 PLFLT temp2 ;
7651 int res2 = SWIG_TMPOBJ ;
7652 PLFLT temp3 ;
7653 int res3 = SWIG_TMPOBJ ;
7654 PLFLT temp4 ;
7655 int res4 = SWIG_TMPOBJ ;
7656
7657 arg1 = &temp1;
7658 arg2 = &temp2;
7659 arg3 = &temp3;
7660 arg4 = &temp4;
7661 (void)self;
7662 if (!SWIG_Python_UnpackTuple(args, "plgvpd", 0, 0, 0)) SWIG_fail;
7663 plgvpd(arg1,arg2,arg3,arg4);
7664 resultobj = SWIG_Py_Void();
7665 if (SWIG_IsTmpObj(res1)) {
7666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7667 } else {
7668 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7669 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7670 }
7671 if (SWIG_IsTmpObj(res2)) {
7672 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7673 } else {
7674 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7675 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7676 }
7677 if (SWIG_IsTmpObj(res3)) {
7678 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7679 } else {
7680 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7681 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7682 }
7683 if (SWIG_IsTmpObj(res4)) {
7684 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7685 } else {
7686 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7687 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7688 }
7689 return resultobj;
7690fail:
7691 return NULL;
7692}
7693
7694
7695SWIGINTERN PyObject *_wrap_plgvpw(PyObject *self, PyObject *args) {
7696 PyObject *resultobj = 0;
7697 PLFLT *arg1 = (PLFLT *) 0 ;
7698 PLFLT *arg2 = (PLFLT *) 0 ;
7699 PLFLT *arg3 = (PLFLT *) 0 ;
7700 PLFLT *arg4 = (PLFLT *) 0 ;
7701 PLFLT temp1 ;
7702 int res1 = SWIG_TMPOBJ ;
7703 PLFLT temp2 ;
7704 int res2 = SWIG_TMPOBJ ;
7705 PLFLT temp3 ;
7706 int res3 = SWIG_TMPOBJ ;
7707 PLFLT temp4 ;
7708 int res4 = SWIG_TMPOBJ ;
7709
7710 arg1 = &temp1;
7711 arg2 = &temp2;
7712 arg3 = &temp3;
7713 arg4 = &temp4;
7714 (void)self;
7715 if (!SWIG_Python_UnpackTuple(args, "plgvpw", 0, 0, 0)) SWIG_fail;
7716 plgvpw(arg1,arg2,arg3,arg4);
7717 resultobj = SWIG_Py_Void();
7718 if (SWIG_IsTmpObj(res1)) {
7719 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
7720 } else {
7721 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
7723 }
7724 if (SWIG_IsTmpObj(res2)) {
7725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
7726 } else {
7727 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
7729 }
7730 if (SWIG_IsTmpObj(res3)) {
7731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
7732 } else {
7733 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
7735 }
7736 if (SWIG_IsTmpObj(res4)) {
7737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7738 } else {
7739 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7741 }
7742 return resultobj;
7743fail:
7744 return NULL;
7745}
7746
7747
7748SWIGINTERN PyObject *_wrap_plgxax(PyObject *self, PyObject *args) {
7749 PyObject *resultobj = 0;
7750 PLINT *arg1 = (PLINT *) 0 ;
7751 PLINT *arg2 = (PLINT *) 0 ;
7752 PLINT temp1 ;
7753 int res1 = SWIG_TMPOBJ ;
7754 PLINT temp2 ;
7755 int res2 = SWIG_TMPOBJ ;
7756
7757 arg1 = &temp1;
7758 arg2 = &temp2;
7759 (void)self;
7760 if (!SWIG_Python_UnpackTuple(args, "plgxax", 0, 0, 0)) SWIG_fail;
7761 plgxax(arg1,arg2);
7762 resultobj = SWIG_Py_Void();
7763 if (SWIG_IsTmpObj(res1)) {
7764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7765 } else {
7766 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7767 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7768 }
7769 if (SWIG_IsTmpObj(res2)) {
7770 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7771 } else {
7772 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7774 }
7775 return resultobj;
7776fail:
7777 return NULL;
7778}
7779
7780
7781SWIGINTERN PyObject *_wrap_plgyax(PyObject *self, PyObject *args) {
7782 PyObject *resultobj = 0;
7783 PLINT *arg1 = (PLINT *) 0 ;
7784 PLINT *arg2 = (PLINT *) 0 ;
7785 PLINT temp1 ;
7786 int res1 = SWIG_TMPOBJ ;
7787 PLINT temp2 ;
7788 int res2 = SWIG_TMPOBJ ;
7789
7790 arg1 = &temp1;
7791 arg2 = &temp2;
7792 (void)self;
7793 if (!SWIG_Python_UnpackTuple(args, "plgyax", 0, 0, 0)) SWIG_fail;
7794 plgyax(arg1,arg2);
7795 resultobj = SWIG_Py_Void();
7796 if (SWIG_IsTmpObj(res1)) {
7797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7798 } else {
7799 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7801 }
7802 if (SWIG_IsTmpObj(res2)) {
7803 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7804 } else {
7805 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7806 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7807 }
7808 return resultobj;
7809fail:
7810 return NULL;
7811}
7812
7813
7814SWIGINTERN PyObject *_wrap_plgzax(PyObject *self, PyObject *args) {
7815 PyObject *resultobj = 0;
7816 PLINT *arg1 = (PLINT *) 0 ;
7817 PLINT *arg2 = (PLINT *) 0 ;
7818 PLINT temp1 ;
7819 int res1 = SWIG_TMPOBJ ;
7820 PLINT temp2 ;
7821 int res2 = SWIG_TMPOBJ ;
7822
7823 arg1 = &temp1;
7824 arg2 = &temp2;
7825 (void)self;
7826 if (!SWIG_Python_UnpackTuple(args, "plgzax", 0, 0, 0)) SWIG_fail;
7827 plgzax(arg1,arg2);
7828 resultobj = SWIG_Py_Void();
7829 if (SWIG_IsTmpObj(res1)) {
7830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
7831 } else {
7832 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
7834 }
7835 if (SWIG_IsTmpObj(res2)) {
7836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7837 } else {
7838 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7840 }
7841 return resultobj;
7842fail:
7843 return NULL;
7844}
7845
7846
7847SWIGINTERN PyObject *_wrap_plhist(PyObject *self, PyObject *args) {
7848 PyObject *resultobj = 0;
7849 PLINT arg1 ;
7850 PLFLT *arg2 = (PLFLT *) 0 ;
7851 PLFLT arg3 ;
7852 PLFLT arg4 ;
7853 PLINT arg5 ;
7854 PLINT arg6 ;
7855 PyArrayObject *tmp1 = NULL ;
7856 double val3 ;
7857 int ecode3 = 0 ;
7858 double val4 ;
7859 int ecode4 = 0 ;
7860 int val5 ;
7861 int ecode5 = 0 ;
7862 int val6 ;
7863 int ecode6 = 0 ;
7864 PyObject *swig_obj[5] ;
7865
7866 (void)self;
7867 if (!SWIG_Python_UnpackTuple(args, "plhist", 5, 5, swig_obj)) SWIG_fail;
7868 {
7869 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7870 if ( tmp1 == NULL )
7871 return NULL;
7872 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7873 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7874 }
7875 ecode3 = SWIG_AsVal_double(swig_obj[1], &val3);
7876 if (!SWIG_IsOK(ecode3)) {
7877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7878 }
7879 arg3 = (PLFLT)(val3);
7880 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
7881 if (!SWIG_IsOK(ecode4)) {
7882 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7883 }
7884 arg4 = (PLFLT)(val4);
7885 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
7886 if (!SWIG_IsOK(ecode5)) {
7887 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7888 }
7889 arg5 = (PLINT)(val5);
7890 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
7891 if (!SWIG_IsOK(ecode6)) {
7892 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7893 }
7894 arg6 = (PLINT)(val6);
7895 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7896 resultobj = SWIG_Py_Void();
7897 {
7898 Py_CLEAR( tmp1 );
7899 }
7900 return resultobj;
7901fail:
7902 {
7903 Py_CLEAR( tmp1 );
7904 }
7905 return NULL;
7906}
7907
7908
7909SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *self, PyObject *args) {
7910 PyObject *resultobj = 0;
7911 PLFLT arg1 ;
7912 PLFLT arg2 ;
7913 PLFLT arg3 ;
7914 PLFLT *arg4 = (PLFLT *) 0 ;
7915 PLFLT *arg5 = (PLFLT *) 0 ;
7916 PLFLT *arg6 = (PLFLT *) 0 ;
7917 double val1 ;
7918 int ecode1 = 0 ;
7919 double val2 ;
7920 int ecode2 = 0 ;
7921 double val3 ;
7922 int ecode3 = 0 ;
7923 PLFLT temp4 ;
7924 int res4 = SWIG_TMPOBJ ;
7925 PLFLT temp5 ;
7926 int res5 = SWIG_TMPOBJ ;
7927 PLFLT temp6 ;
7928 int res6 = SWIG_TMPOBJ ;
7929 PyObject *swig_obj[3] ;
7930
7931 arg4 = &temp4;
7932 arg5 = &temp5;
7933 arg6 = &temp6;
7934 (void)self;
7935 if (!SWIG_Python_UnpackTuple(args, "plhlsrgb", 3, 3, swig_obj)) SWIG_fail;
7936 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7937 if (!SWIG_IsOK(ecode1)) {
7938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7939 }
7940 arg1 = (PLFLT)(val1);
7941 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7942 if (!SWIG_IsOK(ecode2)) {
7943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7944 }
7945 arg2 = (PLFLT)(val2);
7946 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7947 if (!SWIG_IsOK(ecode3)) {
7948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7949 }
7950 arg3 = (PLFLT)(val3);
7951 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7952 resultobj = SWIG_Py_Void();
7953 if (SWIG_IsTmpObj(res4)) {
7954 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
7955 } else {
7956 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7957 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
7958 }
7959 if (SWIG_IsTmpObj(res5)) {
7960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
7961 } else {
7962 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
7964 }
7965 if (SWIG_IsTmpObj(res6)) {
7966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
7967 } else {
7968 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
7970 }
7971 return resultobj;
7972fail:
7973 return NULL;
7974}
7975
7976
7977SWIGINTERN PyObject *_wrap_plinit(PyObject *self, PyObject *args) {
7978 PyObject *resultobj = 0;
7979
7980 (void)self;
7981 if (!SWIG_Python_UnpackTuple(args, "plinit", 0, 0, 0)) SWIG_fail;
7982 plinit();
7983 resultobj = SWIG_Py_Void();
7984 return resultobj;
7985fail:
7986 return NULL;
7987}
7988
7989
7990SWIGINTERN PyObject *_wrap_pljoin(PyObject *self, PyObject *args) {
7991 PyObject *resultobj = 0;
7992 PLFLT arg1 ;
7993 PLFLT arg2 ;
7994 PLFLT arg3 ;
7995 PLFLT arg4 ;
7996 double val1 ;
7997 int ecode1 = 0 ;
7998 double val2 ;
7999 int ecode2 = 0 ;
8000 double val3 ;
8001 int ecode3 = 0 ;
8002 double val4 ;
8003 int ecode4 = 0 ;
8004 PyObject *swig_obj[4] ;
8005
8006 (void)self;
8007 if (!SWIG_Python_UnpackTuple(args, "pljoin", 4, 4, swig_obj)) SWIG_fail;
8008 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8009 if (!SWIG_IsOK(ecode1)) {
8010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
8011 }
8012 arg1 = (PLFLT)(val1);
8013 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8014 if (!SWIG_IsOK(ecode2)) {
8015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
8016 }
8017 arg2 = (PLFLT)(val2);
8018 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8019 if (!SWIG_IsOK(ecode3)) {
8020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
8021 }
8022 arg3 = (PLFLT)(val3);
8023 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8024 if (!SWIG_IsOK(ecode4)) {
8025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
8026 }
8027 arg4 = (PLFLT)(val4);
8028 pljoin(arg1,arg2,arg3,arg4);
8029 resultobj = SWIG_Py_Void();
8030 return resultobj;
8031fail:
8032 return NULL;
8033}
8034
8035
8036SWIGINTERN PyObject *_wrap_pllab(PyObject *self, PyObject *args) {
8037 PyObject *resultobj = 0;
8038 char *arg1 = (char *) 0 ;
8039 char *arg2 = (char *) 0 ;
8040 char *arg3 = (char *) 0 ;
8041 int res1 ;
8042 char *buf1 = 0 ;
8043 int alloc1 = 0 ;
8044 int res2 ;
8045 char *buf2 = 0 ;
8046 int alloc2 = 0 ;
8047 int res3 ;
8048 char *buf3 = 0 ;
8049 int alloc3 = 0 ;
8050 PyObject *swig_obj[3] ;
8051
8052 (void)self;
8053 if (!SWIG_Python_UnpackTuple(args, "pllab", 3, 3, swig_obj)) SWIG_fail;
8054 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8055 if (!SWIG_IsOK(res1)) {
8056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
8057 }
8058 arg1 = (char *)(buf1);
8059 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
8060 if (!SWIG_IsOK(res2)) {
8061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
8062 }
8063 arg2 = (char *)(buf2);
8064 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
8065 if (!SWIG_IsOK(res3)) {
8066 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
8067 }
8068 arg3 = (char *)(buf3);
8069 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
8070 resultobj = SWIG_Py_Void();
8071 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8072 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8073 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8074 return resultobj;
8075fail:
8076 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8077 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8078 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8079 return NULL;
8080}
8081
8082
8083SWIGINTERN PyObject *_wrap_pllegend(PyObject *self, PyObject *args) {
8084 PyObject *resultobj = 0;
8085 PLFLT *arg1 = (PLFLT *) 0 ;
8086 PLFLT *arg2 = (PLFLT *) 0 ;
8087 PLINT arg3 ;
8088 PLINT arg4 ;
8089 PLFLT arg5 ;
8090 PLFLT arg6 ;
8091 PLFLT arg7 ;
8092 PLINT arg8 ;
8093 PLINT arg9 ;
8094 PLINT arg10 ;
8095 PLINT arg11 ;
8096 PLINT arg12 ;
8097 PLINT arg13 ;
8098 PLINT *arg14 = (PLINT *) 0 ;
8099 PLFLT arg15 ;
8100 PLFLT arg16 ;
8101 PLFLT arg17 ;
8102 PLFLT arg18 ;
8103 PLINT *arg19 = (PLINT *) 0 ;
8104 char **arg20 = (char **) 0 ;
8105 PLINT *arg21 = (PLINT *) 0 ;
8106 PLINT *arg22 = (PLINT *) 0 ;
8107 PLFLT *arg23 = (PLFLT *) 0 ;
8108 PLFLT *arg24 = (PLFLT *) 0 ;
8109 PLINT *arg25 = (PLINT *) 0 ;
8110 PLINT *arg26 = (PLINT *) 0 ;
8111 PLFLT *arg27 = (PLFLT *) 0 ;
8112 PLINT *arg28 = (PLINT *) 0 ;
8113 PLFLT *arg29 = (PLFLT *) 0 ;
8114 PLINT *arg30 = (PLINT *) 0 ;
8115 char **arg31 = (char **) 0 ;
8116 PLFLT temp1 ;
8117 int res1 = SWIG_TMPOBJ ;
8118 PLFLT temp2 ;
8119 int res2 = SWIG_TMPOBJ ;
8120 int val3 ;
8121 int ecode3 = 0 ;
8122 int val4 ;
8123 int ecode4 = 0 ;
8124 double val5 ;
8125 int ecode5 = 0 ;
8126 double val6 ;
8127 int ecode6 = 0 ;
8128 double val7 ;
8129 int ecode7 = 0 ;
8130 int val8 ;
8131 int ecode8 = 0 ;
8132 int val9 ;
8133 int ecode9 = 0 ;
8134 int val10 ;
8135 int ecode10 = 0 ;
8136 int val11 ;
8137 int ecode11 = 0 ;
8138 int val12 ;
8139 int ecode12 = 0 ;
8140 PyArrayObject *tmp13 = NULL ;
8141 double val15 ;
8142 int ecode15 = 0 ;
8143 double val16 ;
8144 int ecode16 = 0 ;
8145 double val17 ;
8146 int ecode17 = 0 ;
8147 double val18 ;
8148 int ecode18 = 0 ;
8149 PyArrayObject *tmp19 = NULL ;
8150 PyArrayObject *tmp20 = NULL ;
8151 PyArrayObject *tmp21 = NULL ;
8152 PyArrayObject *tmp22 = NULL ;
8153 PyArrayObject *tmp23 = NULL ;
8154 PyArrayObject *tmp24 = NULL ;
8155 PyArrayObject *tmp25 = NULL ;
8156 PyArrayObject *tmp26 = NULL ;
8157 PyArrayObject *tmp27 = NULL ;
8158 PyArrayObject *tmp28 = NULL ;
8159 PyArrayObject *tmp29 = NULL ;
8160 PyArrayObject *tmp30 = NULL ;
8161 PyArrayObject *tmp31 = NULL ;
8162 PyObject *swig_obj[28] ;
8163
8164 arg1 = &temp1;
8165 arg2 = &temp2;
8166 (void)self;
8167 if (!SWIG_Python_UnpackTuple(args, "pllegend", 28, 28, swig_obj)) SWIG_fail;
8168 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8169 if (!SWIG_IsOK(ecode3)) {
8170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
8171 }
8172 arg3 = (PLINT)(val3);
8173 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8174 if (!SWIG_IsOK(ecode4)) {
8175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
8176 }
8177 arg4 = (PLINT)(val4);
8178 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8179 if (!SWIG_IsOK(ecode5)) {
8180 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
8181 }
8182 arg5 = (PLFLT)(val5);
8183 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8184 if (!SWIG_IsOK(ecode6)) {
8185 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
8186 }
8187 arg6 = (PLFLT)(val6);
8188 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8189 if (!SWIG_IsOK(ecode7)) {
8190 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
8191 }
8192 arg7 = (PLFLT)(val7);
8193 ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
8194 if (!SWIG_IsOK(ecode8)) {
8195 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
8196 }
8197 arg8 = (PLINT)(val8);
8198 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8199 if (!SWIG_IsOK(ecode9)) {
8200 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
8201 }
8202 arg9 = (PLINT)(val9);
8203 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8204 if (!SWIG_IsOK(ecode10)) {
8205 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
8206 }
8207 arg10 = (PLINT)(val10);
8208 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8209 if (!SWIG_IsOK(ecode11)) {
8210 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
8211 }
8212 arg11 = (PLINT)(val11);
8213 ecode12 = SWIG_AsVal_int(swig_obj[9], &val12);
8214 if (!SWIG_IsOK(ecode12)) {
8215 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
8216 }
8217 arg12 = (PLINT)(val12);
8218 {
8219 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[10], NPY_PLINT, 1, 1 );
8220 if ( tmp13 == NULL )
8221 return NULL;
8222 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
8223 arg14 = (PLINT *) PyArray_DATA( tmp13 );
8224 }
8225 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
8226 if (!SWIG_IsOK(ecode15)) {
8227 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
8228 }
8229 arg15 = (PLFLT)(val15);
8230 ecode16 = SWIG_AsVal_double(swig_obj[12], &val16);
8231 if (!SWIG_IsOK(ecode16)) {
8232 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
8233 }
8234 arg16 = (PLFLT)(val16);
8235 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
8236 if (!SWIG_IsOK(ecode17)) {
8237 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
8238 }
8239 arg17 = (PLFLT)(val17);
8240 ecode18 = SWIG_AsVal_double(swig_obj[14], &val18);
8241 if (!SWIG_IsOK(ecode18)) {
8242 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
8243 }
8244 arg18 = (PLFLT)(val18);
8245 {
8246 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[15], NPY_PLINT, 1, 1 );
8247 if ( tmp19 == NULL )
8248 return NULL;
8249 if ( PyArray_DIMS( tmp19 )[0] != Alen )
8250 {
8251 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8252 return NULL;
8253 }
8254 arg19 = (PLINT *) PyArray_DATA( tmp19 );
8255 }
8256 {
8257 int i;
8258 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[16], NPY_STRING, 1, 1 );
8259 if ( tmp20 == NULL )
8260 return NULL;
8261 if ( PyArray_DIMS( tmp20 )[0] != Alen )
8262 {
8263 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8264 return NULL;
8265 }
8266 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8267 for ( i = 0; i < Alen; i++ )
8268 {
8269 arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8270 if ( arg20[i] == NULL )
8271 {
8272 free( arg20 );
8273 return NULL;
8274 }
8275 }
8276 }
8277 {
8278 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8279 if ( tmp21 == NULL )
8280 return NULL;
8281 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8282 {
8283 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8284 return NULL;
8285 }
8286 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8287 }
8288 {
8289 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8290 if ( tmp22 == NULL )
8291 return NULL;
8292 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8293 {
8294 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8295 return NULL;
8296 }
8297 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8298 }
8299 {
8300 if ( swig_obj[19] != Py_None )
8301 {
8302 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 1, 1 );
8303 if ( tmp23 == NULL )
8304 return NULL;
8305 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8306 {
8307 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8308 return NULL;
8309 }
8310 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8311 }
8312 else
8313 {
8314 arg23 = NULL;
8315 }
8316 }
8317 {
8318 if ( swig_obj[20] != Py_None )
8319 {
8320 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[20], NPY_PLFLT, 1, 1 );
8321 if ( tmp24 == NULL )
8322 return NULL;
8323 if ( PyArray_DIMS( tmp24 )[0] != Alen )
8324 {
8325 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8326 return NULL;
8327 }
8328 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8329 }
8330 else
8331 {
8332 arg24 = NULL;
8333 }
8334 }
8335 {
8336 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[21], NPY_PLINT, 1, 1 );
8337 if ( tmp25 == NULL )
8338 return NULL;
8339 if ( PyArray_DIMS( tmp25 )[0] != Alen )
8340 {
8341 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8342 return NULL;
8343 }
8344 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8345 }
8346 {
8347 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[22], NPY_PLINT, 1, 1 );
8348 if ( tmp26 == NULL )
8349 return NULL;
8350 if ( PyArray_DIMS( tmp26 )[0] != Alen )
8351 {
8352 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8353 return NULL;
8354 }
8355 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8356 }
8357 {
8358 if ( swig_obj[23] != Py_None )
8359 {
8360 tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[23], NPY_PLFLT, 1, 1 );
8361 if ( tmp27 == NULL )
8362 return NULL;
8363 if ( PyArray_DIMS( tmp27 )[0] != Alen )
8364 {
8365 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8366 return NULL;
8367 }
8368 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8369 }
8370 else
8371 {
8372 arg27 = NULL;
8373 }
8374 }
8375 {
8376 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[24], NPY_PLINT, 1, 1 );
8377 if ( tmp28 == NULL )
8378 return NULL;
8379 if ( PyArray_DIMS( tmp28 )[0] != Alen )
8380 {
8381 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8382 return NULL;
8383 }
8384 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8385 }
8386 {
8387 if ( swig_obj[25] != Py_None )
8388 {
8389 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[25], NPY_PLFLT, 1, 1 );
8390 if ( tmp29 == NULL )
8391 return NULL;
8392 if ( PyArray_DIMS( tmp29 )[0] != Alen )
8393 {
8394 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8395 return NULL;
8396 }
8397 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8398 }
8399 else
8400 {
8401 arg29 = NULL;
8402 }
8403 }
8404 {
8405 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[26], NPY_PLINT, 1, 1 );
8406 if ( tmp30 == NULL )
8407 return NULL;
8408 if ( PyArray_DIMS( tmp30 )[0] != Alen )
8409 {
8410 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8411 return NULL;
8412 }
8413 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8414 }
8415 {
8416 int i;
8417 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[27], NPY_STRING, 1, 1 );
8418 if ( tmp31 == NULL )
8419 return NULL;
8420 if ( PyArray_DIMS( tmp31 )[0] != Alen )
8421 {
8422 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8423 return NULL;
8424 }
8425 arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8426 for ( i = 0; i < Alen; i++ )
8427 {
8428 arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8429 if ( arg31[i] == NULL )
8430 {
8431 free( arg31 );
8432 return NULL;
8433 }
8434 }
8435 }
8436 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);
8437 resultobj = SWIG_Py_Void();
8438 if (SWIG_IsTmpObj(res1)) {
8439 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8440 } else {
8441 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8442 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8443 }
8444 if (SWIG_IsTmpObj(res2)) {
8445 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8446 } else {
8447 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8448 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8449 }
8450 {
8451 Py_CLEAR( tmp13 );
8452 }
8453 {
8454 Py_CLEAR( tmp19 );
8455 }
8456 {
8457 Py_CLEAR( tmp20 ); free( arg20 );
8458 }
8459 {
8460 Py_CLEAR( tmp21 );
8461 }
8462 {
8463 Py_CLEAR( tmp22 );
8464 }
8465 {
8466 Py_CLEAR( tmp23 );
8467 }
8468 {
8469 Py_CLEAR( tmp24 );
8470 }
8471 {
8472 Py_CLEAR( tmp25 );
8473 }
8474 {
8475 Py_CLEAR( tmp26 );
8476 }
8477 {
8478 Py_CLEAR( tmp27 );
8479 }
8480 {
8481 Py_CLEAR( tmp28 );
8482 }
8483 {
8484 Py_CLEAR( tmp29 );
8485 }
8486 {
8487 Py_CLEAR( tmp30 );
8488 }
8489 {
8490 Py_CLEAR( tmp31 ); free( arg31 );
8491 }
8492 return resultobj;
8493fail:
8494 {
8495 Py_CLEAR( tmp13 );
8496 }
8497 {
8498 Py_CLEAR( tmp19 );
8499 }
8500 {
8501 Py_CLEAR( tmp20 ); free( arg20 );
8502 }
8503 {
8504 Py_CLEAR( tmp21 );
8505 }
8506 {
8507 Py_CLEAR( tmp22 );
8508 }
8509 {
8510 Py_CLEAR( tmp23 );
8511 }
8512 {
8513 Py_CLEAR( tmp24 );
8514 }
8515 {
8516 Py_CLEAR( tmp25 );
8517 }
8518 {
8519 Py_CLEAR( tmp26 );
8520 }
8521 {
8522 Py_CLEAR( tmp27 );
8523 }
8524 {
8525 Py_CLEAR( tmp28 );
8526 }
8527 {
8528 Py_CLEAR( tmp29 );
8529 }
8530 {
8531 Py_CLEAR( tmp30 );
8532 }
8533 {
8534 Py_CLEAR( tmp31 ); free( arg31 );
8535 }
8536 return NULL;
8537}
8538
8539
8540SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *self, PyObject *args) {
8541 PyObject *resultobj = 0;
8542 PLFLT *arg1 = (PLFLT *) 0 ;
8543 PLFLT *arg2 = (PLFLT *) 0 ;
8544 PLINT arg3 ;
8545 PLINT arg4 ;
8546 PLFLT arg5 ;
8547 PLFLT arg6 ;
8548 PLFLT arg7 ;
8549 PLFLT arg8 ;
8550 PLINT arg9 ;
8551 PLINT arg10 ;
8552 PLINT arg11 ;
8553 PLFLT arg12 ;
8554 PLFLT arg13 ;
8555 PLINT arg14 ;
8556 PLFLT arg15 ;
8557 PLINT arg16 ;
8558 PLINT *arg17 = (PLINT *) 0 ;
8559 char **arg18 = (char **) 0 ;
8560 PLINT arg19 ;
8561 char **arg20 = (char **) 0 ;
8562 PLFLT *arg21 = (PLFLT *) 0 ;
8563 PLINT *arg22 = (PLINT *) 0 ;
8564 PLINT *arg23 = (PLINT *) 0 ;
8565 PLFLT **arg24 = (PLFLT **) 0 ;
8566 PLFLT temp1 ;
8567 int res1 = SWIG_TMPOBJ ;
8568 PLFLT temp2 ;
8569 int res2 = SWIG_TMPOBJ ;
8570 int val3 ;
8571 int ecode3 = 0 ;
8572 int val4 ;
8573 int ecode4 = 0 ;
8574 double val5 ;
8575 int ecode5 = 0 ;
8576 double val6 ;
8577 int ecode6 = 0 ;
8578 double val7 ;
8579 int ecode7 = 0 ;
8580 double val8 ;
8581 int ecode8 = 0 ;
8582 int val9 ;
8583 int ecode9 = 0 ;
8584 int val10 ;
8585 int ecode10 = 0 ;
8586 int val11 ;
8587 int ecode11 = 0 ;
8588 double val12 ;
8589 int ecode12 = 0 ;
8590 double val13 ;
8591 int ecode13 = 0 ;
8592 int val14 ;
8593 int ecode14 = 0 ;
8594 double val15 ;
8595 int ecode15 = 0 ;
8596 PyArrayObject *tmp16 = NULL ;
8597 PyArrayObject *tmp18 = NULL ;
8598 PyArrayObject *tmp19 = NULL ;
8599 PyArrayObject *tmp21 = NULL ;
8600 PyArrayObject *tmp22 = NULL ;
8601 PyArrayObject *tmp23 = NULL ;
8602 PyArrayObject *tmp24 = NULL ;
8603 PyObject *swig_obj[20] ;
8604
8605 arg1 = &temp1;
8606 arg2 = &temp2;
8607 (void)self;
8608 if (!SWIG_Python_UnpackTuple(args, "plcolorbar", 20, 20, swig_obj)) SWIG_fail;
8609 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8610 if (!SWIG_IsOK(ecode3)) {
8611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8612 }
8613 arg3 = (PLINT)(val3);
8614 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8615 if (!SWIG_IsOK(ecode4)) {
8616 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8617 }
8618 arg4 = (PLINT)(val4);
8619 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8620 if (!SWIG_IsOK(ecode5)) {
8621 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8622 }
8623 arg5 = (PLFLT)(val5);
8624 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8625 if (!SWIG_IsOK(ecode6)) {
8626 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8627 }
8628 arg6 = (PLFLT)(val6);
8629 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8630 if (!SWIG_IsOK(ecode7)) {
8631 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8632 }
8633 arg7 = (PLFLT)(val7);
8634 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
8635 if (!SWIG_IsOK(ecode8)) {
8636 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8637 }
8638 arg8 = (PLFLT)(val8);
8639 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8640 if (!SWIG_IsOK(ecode9)) {
8641 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8642 }
8643 arg9 = (PLINT)(val9);
8644 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8645 if (!SWIG_IsOK(ecode10)) {
8646 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8647 }
8648 arg10 = (PLINT)(val10);
8649 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8650 if (!SWIG_IsOK(ecode11)) {
8651 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8652 }
8653 arg11 = (PLINT)(val11);
8654 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
8655 if (!SWIG_IsOK(ecode12)) {
8656 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8657 }
8658 arg12 = (PLFLT)(val12);
8659 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
8660 if (!SWIG_IsOK(ecode13)) {
8661 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8662 }
8663 arg13 = (PLFLT)(val13);
8664 ecode14 = SWIG_AsVal_int(swig_obj[11], &val14);
8665 if (!SWIG_IsOK(ecode14)) {
8666 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8667 }
8668 arg14 = (PLINT)(val14);
8669 ecode15 = SWIG_AsVal_double(swig_obj[12], &val15);
8670 if (!SWIG_IsOK(ecode15)) {
8671 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8672 }
8673 arg15 = (PLFLT)(val15);
8674 {
8675 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
8676 if ( tmp16 == NULL )
8677 return NULL;
8678 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8679 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8680 }
8681 {
8682 int i;
8683 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[14], NPY_STRING, 1, 1 );
8684 if ( tmp18 == NULL )
8685 return NULL;
8686 if ( PyArray_DIMS( tmp18 )[0] != Alen )
8687 {
8688 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8689 return NULL;
8690 }
8691 arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8692 for ( i = 0; i < Alen; i++ )
8693 {
8694 arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8695 if ( arg18[i] == NULL )
8696 {
8697 free( arg18 );
8698 return NULL;
8699 }
8700 }
8701 }
8702 {
8703 int i;
8704 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[15], NPY_STRING, 1, 1 );
8705 if ( tmp19 == NULL )
8706 return NULL;
8707 Alen = PyArray_DIMS( tmp19 )[0];
8708 arg19 = Alen;
8709 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8710 for ( i = 0; i < Alen; i++ )
8711 {
8712 arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8713 if ( arg20[i] == NULL )
8714 {
8715 free( arg20 );
8716 return NULL;
8717 }
8718 }
8719 }
8720 {
8721 tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[16], NPY_PLFLT, 1, 1 );
8722 if ( tmp21 == NULL )
8723 return NULL;
8724 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8725 {
8726 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8727 return NULL;
8728 }
8729 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8730 }
8731 {
8732 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8733 if ( tmp22 == NULL )
8734 return NULL;
8735 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8736 {
8737 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8738 return NULL;
8739 }
8740 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8741 }
8742 {
8743 int i;
8744 tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8745 if ( tmp23 == NULL )
8746 return NULL;
8747 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8748 {
8749 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8750 return NULL;
8751 }
8752 Xlen = PyArray_DIMS( tmp23 )[0];
8753 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8754 Ylen = -1;
8755 for ( i = 0; i < Xlen; i++ )
8756 if ( arg23[i] > Ylen )
8757 Ylen = arg23[i];
8758 }
8759 {
8760 int i, size;
8761 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 2, 2 );
8762 if ( tmp24 == NULL )
8763 return NULL;
8764 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8765 {
8766 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8767 return NULL;
8768 }
8769 size = Ylen;
8770 arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8771 for ( i = 0; i < Xlen; i++ )
8772 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8773 }
8774 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);
8775 resultobj = SWIG_Py_Void();
8776 if (SWIG_IsTmpObj(res1)) {
8777 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
8778 } else {
8779 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8780 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8781 }
8782 if (SWIG_IsTmpObj(res2)) {
8783 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
8784 } else {
8785 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8786 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8787 }
8788 {
8789 Py_CLEAR( tmp16 );
8790 }
8791 {
8792 Py_CLEAR( tmp18 ); free( arg18 );
8793 }
8794 {
8795 Py_CLEAR( tmp19 ); free( arg20 );
8796 }
8797 {
8798 Py_CLEAR( tmp21 );
8799 }
8800 {
8801 Py_CLEAR( tmp22 );
8802 }
8803 {
8804 Py_CLEAR( tmp23 );
8805 }
8806 {
8807 Py_CLEAR( tmp24 );
8808 free( arg24 );
8809 }
8810 return resultobj;
8811fail:
8812 {
8813 Py_CLEAR( tmp16 );
8814 }
8815 {
8816 Py_CLEAR( tmp18 ); free( arg18 );
8817 }
8818 {
8819 Py_CLEAR( tmp19 ); free( arg20 );
8820 }
8821 {
8822 Py_CLEAR( tmp21 );
8823 }
8824 {
8825 Py_CLEAR( tmp22 );
8826 }
8827 {
8828 Py_CLEAR( tmp23 );
8829 }
8830 {
8831 Py_CLEAR( tmp24 );
8832 free( arg24 );
8833 }
8834 return NULL;
8835}
8836
8837
8838SWIGINTERN PyObject *_wrap_pllightsource(PyObject *self, PyObject *args) {
8839 PyObject *resultobj = 0;
8840 PLFLT arg1 ;
8841 PLFLT arg2 ;
8842 PLFLT arg3 ;
8843 double val1 ;
8844 int ecode1 = 0 ;
8845 double val2 ;
8846 int ecode2 = 0 ;
8847 double val3 ;
8848 int ecode3 = 0 ;
8849 PyObject *swig_obj[3] ;
8850
8851 (void)self;
8852 if (!SWIG_Python_UnpackTuple(args, "pllightsource", 3, 3, swig_obj)) SWIG_fail;
8853 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8854 if (!SWIG_IsOK(ecode1)) {
8855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8856 }
8857 arg1 = (PLFLT)(val1);
8858 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8859 if (!SWIG_IsOK(ecode2)) {
8860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8861 }
8862 arg2 = (PLFLT)(val2);
8863 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8864 if (!SWIG_IsOK(ecode3)) {
8865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8866 }
8867 arg3 = (PLFLT)(val3);
8868 pllightsource(arg1,arg2,arg3);
8869 resultobj = SWIG_Py_Void();
8870 return resultobj;
8871fail:
8872 return NULL;
8873}
8874
8875
8876SWIGINTERN PyObject *_wrap_plline(PyObject *self, PyObject *args) {
8877 PyObject *resultobj = 0;
8878 PLINT arg1 ;
8879 PLFLT *arg2 = (PLFLT *) 0 ;
8880 PLFLT *arg3 = (PLFLT *) 0 ;
8881 PyArrayObject *tmp1 = NULL ;
8882 PyArrayObject *tmp3 = NULL ;
8883 PyObject *swig_obj[2] ;
8884
8885 (void)self;
8886 if (!SWIG_Python_UnpackTuple(args, "plline", 2, 2, swig_obj)) SWIG_fail;
8887 {
8888 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8889 if ( tmp1 == NULL )
8890 return NULL;
8891 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8892 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8893 }
8894 {
8895 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8896 if ( tmp3 == NULL )
8897 return NULL;
8898 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8899 {
8900 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8901 return NULL;
8902 }
8903 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8904 }
8905 plline(arg1,(double const *)arg2,(double const *)arg3);
8906 resultobj = SWIG_Py_Void();
8907 {
8908 Py_CLEAR( tmp1 );
8909 }
8910 {
8911 Py_CLEAR( tmp3 );
8912 }
8913 return resultobj;
8914fail:
8915 {
8916 Py_CLEAR( tmp1 );
8917 }
8918 {
8919 Py_CLEAR( tmp3 );
8920 }
8921 return NULL;
8922}
8923
8924
8925SWIGINTERN PyObject *_wrap_plline3(PyObject *self, PyObject *args) {
8926 PyObject *resultobj = 0;
8927 PLINT arg1 ;
8928 PLFLT *arg2 = (PLFLT *) 0 ;
8929 PLFLT *arg3 = (PLFLT *) 0 ;
8930 PLFLT *arg4 = (PLFLT *) 0 ;
8931 PyArrayObject *tmp1 = NULL ;
8932 PyArrayObject *tmp3 = NULL ;
8933 PyArrayObject *tmp4 = NULL ;
8934 PyObject *swig_obj[3] ;
8935
8936 (void)self;
8937 if (!SWIG_Python_UnpackTuple(args, "plline3", 3, 3, swig_obj)) SWIG_fail;
8938 {
8939 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8940 if ( tmp1 == NULL )
8941 return NULL;
8942 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8943 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8944 }
8945 {
8946 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8947 if ( tmp3 == NULL )
8948 return NULL;
8949 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8950 {
8951 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8952 return NULL;
8953 }
8954 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8955 }
8956 {
8957 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
8958 if ( tmp4 == NULL )
8959 return NULL;
8960 if ( PyArray_DIMS( tmp4 )[0] != Alen )
8961 {
8962 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8963 return NULL;
8964 }
8965 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
8966 }
8967 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
8968 resultobj = SWIG_Py_Void();
8969 {
8970 Py_CLEAR( tmp1 );
8971 }
8972 {
8973 Py_CLEAR( tmp3 );
8974 }
8975 {
8976 Py_CLEAR( tmp4 );
8977 }
8978 return resultobj;
8979fail:
8980 {
8981 Py_CLEAR( tmp1 );
8982 }
8983 {
8984 Py_CLEAR( tmp3 );
8985 }
8986 {
8987 Py_CLEAR( tmp4 );
8988 }
8989 return NULL;
8990}
8991
8992
8993SWIGINTERN PyObject *_wrap_pllsty(PyObject *self, PyObject *args) {
8994 PyObject *resultobj = 0;
8995 PLINT arg1 ;
8996 int val1 ;
8997 int ecode1 = 0 ;
8998 PyObject *swig_obj[1] ;
8999
9000 (void)self;
9001 if (!args) SWIG_fail;
9002 swig_obj[0] = args;
9003 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9004 if (!SWIG_IsOK(ecode1)) {
9005 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
9006 }
9007 arg1 = (PLINT)(val1);
9008 pllsty(arg1);
9009 resultobj = SWIG_Py_Void();
9010 return resultobj;
9011fail:
9012 return NULL;
9013}
9014
9015
9016SWIGINTERN PyObject *_wrap_plmesh(PyObject *self, PyObject *args) {
9017 PyObject *resultobj = 0;
9018 PLFLT *arg1 = (PLFLT *) 0 ;
9019 PLFLT *arg2 = (PLFLT *) 0 ;
9020 PLFLT **arg3 = (PLFLT **) 0 ;
9021 PLINT arg4 ;
9022 PLINT arg5 ;
9023 PLINT arg6 ;
9024 PyArrayObject *tmp1 = NULL ;
9025 PyArrayObject *tmp2 = NULL ;
9026 PyArrayObject *tmp3 = NULL ;
9027 int val6 ;
9028 int ecode6 = 0 ;
9029 PyObject *swig_obj[4] ;
9030
9031 (void)self;
9032 if (!SWIG_Python_UnpackTuple(args, "plmesh", 4, 4, swig_obj)) SWIG_fail;
9033 {
9034 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9035 if ( tmp1 == NULL )
9036 return NULL;
9037 Xlen = PyArray_DIMS( tmp1 )[0];
9038 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9039 }
9040 {
9041 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9042 if ( tmp2 == NULL )
9043 return NULL;
9044 Ylen = PyArray_DIMS( tmp2 )[0];
9045 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9046 }
9047 {
9048 int i, size;
9049 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9050 if ( tmp3 == NULL )
9051 return NULL;
9052 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9053 {
9054 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9055 return NULL;
9056 }
9057 arg4 = PyArray_DIMS( tmp3 )[0];
9058 arg5 = PyArray_DIMS( tmp3 )[1];
9059 size = arg5;
9060 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9061 for ( i = 0; i < arg4; i++ )
9062 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9063 }
9064 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9065 if (!SWIG_IsOK(ecode6)) {
9066 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
9067 }
9068 arg6 = (PLINT)(val6);
9069 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
9070 resultobj = SWIG_Py_Void();
9071 {
9072 Py_CLEAR( tmp1 );
9073 }
9074 {
9075 Py_CLEAR( tmp2 );
9076 }
9077 {
9078 Py_CLEAR( tmp3 );
9079 free( arg3 );
9080 }
9081 return resultobj;
9082fail:
9083 {
9084 Py_CLEAR( tmp1 );
9085 }
9086 {
9087 Py_CLEAR( tmp2 );
9088 }
9089 {
9090 Py_CLEAR( tmp3 );
9091 free( arg3 );
9092 }
9093 return NULL;
9094}
9095
9096
9097SWIGINTERN PyObject *_wrap_plmeshc(PyObject *self, PyObject *args) {
9098 PyObject *resultobj = 0;
9099 PLFLT *arg1 = (PLFLT *) 0 ;
9100 PLFLT *arg2 = (PLFLT *) 0 ;
9101 PLFLT **arg3 = (PLFLT **) 0 ;
9102 PLINT arg4 ;
9103 PLINT arg5 ;
9104 PLINT arg6 ;
9105 PLFLT *arg7 = (PLFLT *) 0 ;
9106 PLINT arg8 ;
9107 PyArrayObject *tmp1 = NULL ;
9108 PyArrayObject *tmp2 = NULL ;
9109 PyArrayObject *tmp3 = NULL ;
9110 int val6 ;
9111 int ecode6 = 0 ;
9112 PyArrayObject *tmp7 = NULL ;
9113 PyObject *swig_obj[5] ;
9114
9115 (void)self;
9116 if (!SWIG_Python_UnpackTuple(args, "plmeshc", 5, 5, swig_obj)) SWIG_fail;
9117 {
9118 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9119 if ( tmp1 == NULL )
9120 return NULL;
9121 Xlen = PyArray_DIMS( tmp1 )[0];
9122 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9123 }
9124 {
9125 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9126 if ( tmp2 == NULL )
9127 return NULL;
9128 Ylen = PyArray_DIMS( tmp2 )[0];
9129 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9130 }
9131 {
9132 int i, size;
9133 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9134 if ( tmp3 == NULL )
9135 return NULL;
9136 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9137 {
9138 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9139 return NULL;
9140 }
9141 arg4 = PyArray_DIMS( tmp3 )[0];
9142 arg5 = PyArray_DIMS( tmp3 )[1];
9143 size = arg5;
9144 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9145 for ( i = 0; i < arg4; i++ )
9146 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9147 }
9148 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9149 if (!SWIG_IsOK(ecode6)) {
9150 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9151 }
9152 arg6 = (PLINT)(val6);
9153 {
9154 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9155 if ( tmp7 == NULL )
9156 return NULL;
9157 arg8 = PyArray_DIMS( tmp7 )[0];
9158 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9159 }
9160 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9161 resultobj = SWIG_Py_Void();
9162 {
9163 Py_CLEAR( tmp1 );
9164 }
9165 {
9166 Py_CLEAR( tmp2 );
9167 }
9168 {
9169 Py_CLEAR( tmp3 );
9170 free( arg3 );
9171 }
9172 {
9173 Py_CLEAR( tmp7 );
9174 }
9175 return resultobj;
9176fail:
9177 {
9178 Py_CLEAR( tmp1 );
9179 }
9180 {
9181 Py_CLEAR( tmp2 );
9182 }
9183 {
9184 Py_CLEAR( tmp3 );
9185 free( arg3 );
9186 }
9187 {
9188 Py_CLEAR( tmp7 );
9189 }
9190 return NULL;
9191}
9192
9193
9194SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *self, PyObject *args) {
9195 PyObject *resultobj = 0;
9196 PLINT *arg1 = (PLINT *) 0 ;
9197 PLINT temp1 ;
9198 int res1 = SWIG_TMPOBJ ;
9199
9200 arg1 = &temp1;
9201 (void)self;
9202 if (!SWIG_Python_UnpackTuple(args, "plmkstrm", 0, 0, 0)) SWIG_fail;
9203 plmkstrm(arg1);
9204 resultobj = SWIG_Py_Void();
9205 if (SWIG_IsTmpObj(res1)) {
9206 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
9207 } else {
9208 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9209 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
9210 }
9211 return resultobj;
9212fail:
9213 return NULL;
9214}
9215
9216
9217SWIGINTERN PyObject *_wrap_plmtex(PyObject *self, PyObject *args) {
9218 PyObject *resultobj = 0;
9219 char *arg1 = (char *) 0 ;
9220 PLFLT arg2 ;
9221 PLFLT arg3 ;
9222 PLFLT arg4 ;
9223 char *arg5 = (char *) 0 ;
9224 int res1 ;
9225 char *buf1 = 0 ;
9226 int alloc1 = 0 ;
9227 double val2 ;
9228 int ecode2 = 0 ;
9229 double val3 ;
9230 int ecode3 = 0 ;
9231 double val4 ;
9232 int ecode4 = 0 ;
9233 int res5 ;
9234 char *buf5 = 0 ;
9235 int alloc5 = 0 ;
9236 PyObject *swig_obj[5] ;
9237
9238 (void)self;
9239 if (!SWIG_Python_UnpackTuple(args, "plmtex", 5, 5, swig_obj)) SWIG_fail;
9240 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9241 if (!SWIG_IsOK(res1)) {
9242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
9243 }
9244 arg1 = (char *)(buf1);
9245 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9246 if (!SWIG_IsOK(ecode2)) {
9247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9248 }
9249 arg2 = (PLFLT)(val2);
9250 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9251 if (!SWIG_IsOK(ecode3)) {
9252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9253 }
9254 arg3 = (PLFLT)(val3);
9255 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9256 if (!SWIG_IsOK(ecode4)) {
9257 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9258 }
9259 arg4 = (PLFLT)(val4);
9260 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9261 if (!SWIG_IsOK(res5)) {
9262 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9263 }
9264 arg5 = (char *)(buf5);
9265 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9266 resultobj = SWIG_Py_Void();
9267 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9268 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9269 return resultobj;
9270fail:
9271 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9272 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9273 return NULL;
9274}
9275
9276
9277SWIGINTERN PyObject *_wrap_plmtex3(PyObject *self, PyObject *args) {
9278 PyObject *resultobj = 0;
9279 char *arg1 = (char *) 0 ;
9280 PLFLT arg2 ;
9281 PLFLT arg3 ;
9282 PLFLT arg4 ;
9283 char *arg5 = (char *) 0 ;
9284 int res1 ;
9285 char *buf1 = 0 ;
9286 int alloc1 = 0 ;
9287 double val2 ;
9288 int ecode2 = 0 ;
9289 double val3 ;
9290 int ecode3 = 0 ;
9291 double val4 ;
9292 int ecode4 = 0 ;
9293 int res5 ;
9294 char *buf5 = 0 ;
9295 int alloc5 = 0 ;
9296 PyObject *swig_obj[5] ;
9297
9298 (void)self;
9299 if (!SWIG_Python_UnpackTuple(args, "plmtex3", 5, 5, swig_obj)) SWIG_fail;
9300 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9301 if (!SWIG_IsOK(res1)) {
9302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9303 }
9304 arg1 = (char *)(buf1);
9305 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9306 if (!SWIG_IsOK(ecode2)) {
9307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9308 }
9309 arg2 = (PLFLT)(val2);
9310 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9311 if (!SWIG_IsOK(ecode3)) {
9312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9313 }
9314 arg3 = (PLFLT)(val3);
9315 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9316 if (!SWIG_IsOK(ecode4)) {
9317 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9318 }
9319 arg4 = (PLFLT)(val4);
9320 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9321 if (!SWIG_IsOK(res5)) {
9322 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9323 }
9324 arg5 = (char *)(buf5);
9325 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9326 resultobj = SWIG_Py_Void();
9327 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9328 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9329 return resultobj;
9330fail:
9331 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9332 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9333 return NULL;
9334}
9335
9336
9337SWIGINTERN PyObject *_wrap_plot3d(PyObject *self, PyObject *args) {
9338 PyObject *resultobj = 0;
9339 PLFLT *arg1 = (PLFLT *) 0 ;
9340 PLFLT *arg2 = (PLFLT *) 0 ;
9341 PLFLT **arg3 = (PLFLT **) 0 ;
9342 PLINT arg4 ;
9343 PLINT arg5 ;
9344 PLINT arg6 ;
9345 PLBOOL arg7 ;
9346 PyArrayObject *tmp1 = NULL ;
9347 PyArrayObject *tmp2 = NULL ;
9348 PyArrayObject *tmp3 = NULL ;
9349 int val6 ;
9350 int ecode6 = 0 ;
9351 int val7 ;
9352 int ecode7 = 0 ;
9353 PyObject *swig_obj[5] ;
9354
9355 (void)self;
9356 if (!SWIG_Python_UnpackTuple(args, "plot3d", 5, 5, swig_obj)) SWIG_fail;
9357 {
9358 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9359 if ( tmp1 == NULL )
9360 return NULL;
9361 Xlen = PyArray_DIMS( tmp1 )[0];
9362 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9363 }
9364 {
9365 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9366 if ( tmp2 == NULL )
9367 return NULL;
9368 Ylen = PyArray_DIMS( tmp2 )[0];
9369 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9370 }
9371 {
9372 int i, size;
9373 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9374 if ( tmp3 == NULL )
9375 return NULL;
9376 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9377 {
9378 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9379 return NULL;
9380 }
9381 arg4 = PyArray_DIMS( tmp3 )[0];
9382 arg5 = PyArray_DIMS( tmp3 )[1];
9383 size = arg5;
9384 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9385 for ( i = 0; i < arg4; i++ )
9386 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9387 }
9388 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9389 if (!SWIG_IsOK(ecode6)) {
9390 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9391 }
9392 arg6 = (PLINT)(val6);
9393 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
9394 if (!SWIG_IsOK(ecode7)) {
9395 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9396 }
9397 arg7 = (PLBOOL)(val7);
9398 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9399 resultobj = SWIG_Py_Void();
9400 {
9401 Py_CLEAR( tmp1 );
9402 }
9403 {
9404 Py_CLEAR( tmp2 );
9405 }
9406 {
9407 Py_CLEAR( tmp3 );
9408 free( arg3 );
9409 }
9410 return resultobj;
9411fail:
9412 {
9413 Py_CLEAR( tmp1 );
9414 }
9415 {
9416 Py_CLEAR( tmp2 );
9417 }
9418 {
9419 Py_CLEAR( tmp3 );
9420 free( arg3 );
9421 }
9422 return NULL;
9423}
9424
9425
9426SWIGINTERN PyObject *_wrap_plot3dc(PyObject *self, PyObject *args) {
9427 PyObject *resultobj = 0;
9428 PLFLT *arg1 = (PLFLT *) 0 ;
9429 PLFLT *arg2 = (PLFLT *) 0 ;
9430 PLFLT **arg3 = (PLFLT **) 0 ;
9431 PLINT arg4 ;
9432 PLINT arg5 ;
9433 PLINT arg6 ;
9434 PLFLT *arg7 = (PLFLT *) 0 ;
9435 PLINT arg8 ;
9436 PyArrayObject *tmp1 = NULL ;
9437 PyArrayObject *tmp2 = NULL ;
9438 PyArrayObject *tmp3 = NULL ;
9439 int val6 ;
9440 int ecode6 = 0 ;
9441 PyArrayObject *tmp7 = NULL ;
9442 PyObject *swig_obj[5] ;
9443
9444 (void)self;
9445 if (!SWIG_Python_UnpackTuple(args, "plot3dc", 5, 5, swig_obj)) SWIG_fail;
9446 {
9447 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9448 if ( tmp1 == NULL )
9449 return NULL;
9450 Xlen = PyArray_DIMS( tmp1 )[0];
9451 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9452 }
9453 {
9454 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9455 if ( tmp2 == NULL )
9456 return NULL;
9457 Ylen = PyArray_DIMS( tmp2 )[0];
9458 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9459 }
9460 {
9461 int i, size;
9462 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9463 if ( tmp3 == NULL )
9464 return NULL;
9465 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9466 {
9467 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9468 return NULL;
9469 }
9470 arg4 = PyArray_DIMS( tmp3 )[0];
9471 arg5 = PyArray_DIMS( tmp3 )[1];
9472 size = arg5;
9473 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9474 for ( i = 0; i < arg4; i++ )
9475 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9476 }
9477 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9478 if (!SWIG_IsOK(ecode6)) {
9479 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9480 }
9481 arg6 = (PLINT)(val6);
9482 {
9483 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9484 if ( tmp7 == NULL )
9485 return NULL;
9486 arg8 = PyArray_DIMS( tmp7 )[0];
9487 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9488 }
9489 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9490 resultobj = SWIG_Py_Void();
9491 {
9492 Py_CLEAR( tmp1 );
9493 }
9494 {
9495 Py_CLEAR( tmp2 );
9496 }
9497 {
9498 Py_CLEAR( tmp3 );
9499 free( arg3 );
9500 }
9501 {
9502 Py_CLEAR( tmp7 );
9503 }
9504 return resultobj;
9505fail:
9506 {
9507 Py_CLEAR( tmp1 );
9508 }
9509 {
9510 Py_CLEAR( tmp2 );
9511 }
9512 {
9513 Py_CLEAR( tmp3 );
9514 free( arg3 );
9515 }
9516 {
9517 Py_CLEAR( tmp7 );
9518 }
9519 return NULL;
9520}
9521
9522
9523SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *self, PyObject *args) {
9524 PyObject *resultobj = 0;
9525 PLFLT *arg1 = (PLFLT *) 0 ;
9526 PLFLT *arg2 = (PLFLT *) 0 ;
9527 PLFLT **arg3 = (PLFLT **) 0 ;
9528 PLINT arg4 ;
9529 PLINT arg5 ;
9530 PLINT arg6 ;
9531 PLFLT *arg7 = (PLFLT *) 0 ;
9532 PLINT arg8 ;
9533 PLINT arg9 ;
9534 PLINT arg10 ;
9535 PLINT *arg11 = (PLINT *) 0 ;
9536 PLINT *arg12 = (PLINT *) 0 ;
9537 PyArrayObject *tmp1 = NULL ;
9538 PyArrayObject *tmp2 = NULL ;
9539 PyArrayObject *tmp3 = NULL ;
9540 int val6 ;
9541 int ecode6 = 0 ;
9542 PyArrayObject *tmp7 = NULL ;
9543 int val9 ;
9544 int ecode9 = 0 ;
9545 PyArrayObject *tmp10 = NULL ;
9546 PyArrayObject *tmp12 = NULL ;
9547 PyObject *swig_obj[8] ;
9548
9549 (void)self;
9550 if (!SWIG_Python_UnpackTuple(args, "plot3dcl", 8, 8, swig_obj)) SWIG_fail;
9551 {
9552 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9553 if ( tmp1 == NULL )
9554 return NULL;
9555 Xlen = PyArray_DIMS( tmp1 )[0];
9556 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9557 }
9558 {
9559 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9560 if ( tmp2 == NULL )
9561 return NULL;
9562 Ylen = PyArray_DIMS( tmp2 )[0];
9563 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9564 }
9565 {
9566 int i, size;
9567 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9568 if ( tmp3 == NULL )
9569 return NULL;
9570 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9571 {
9572 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9573 return NULL;
9574 }
9575 arg4 = PyArray_DIMS( tmp3 )[0];
9576 arg5 = PyArray_DIMS( tmp3 )[1];
9577 size = arg5;
9578 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9579 for ( i = 0; i < arg4; i++ )
9580 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9581 }
9582 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9583 if (!SWIG_IsOK(ecode6)) {
9584 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9585 }
9586 arg6 = (PLINT)(val6);
9587 {
9588 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9589 if ( tmp7 == NULL )
9590 return NULL;
9591 arg8 = PyArray_DIMS( tmp7 )[0];
9592 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9593 }
9594 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9595 if (!SWIG_IsOK(ecode9)) {
9596 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9597 }
9598 arg9 = (PLINT)(val9);
9599 {
9600 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9601 if ( tmp10 == NULL )
9602 return NULL;
9603 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9604 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9605 }
9606 {
9607 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9608 if ( tmp12 == NULL )
9609 return NULL;
9610 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9611 {
9612 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9613 return NULL;
9614 }
9615 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9616 }
9617 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);
9618 resultobj = SWIG_Py_Void();
9619 {
9620 Py_CLEAR( tmp1 );
9621 }
9622 {
9623 Py_CLEAR( tmp2 );
9624 }
9625 {
9626 Py_CLEAR( tmp3 );
9627 free( arg3 );
9628 }
9629 {
9630 Py_CLEAR( tmp7 );
9631 }
9632 {
9633 Py_CLEAR( tmp10 );
9634 }
9635 {
9636 Py_CLEAR( tmp12 );
9637 }
9638 return resultobj;
9639fail:
9640 {
9641 Py_CLEAR( tmp1 );
9642 }
9643 {
9644 Py_CLEAR( tmp2 );
9645 }
9646 {
9647 Py_CLEAR( tmp3 );
9648 free( arg3 );
9649 }
9650 {
9651 Py_CLEAR( tmp7 );
9652 }
9653 {
9654 Py_CLEAR( tmp10 );
9655 }
9656 {
9657 Py_CLEAR( tmp12 );
9658 }
9659 return NULL;
9660}
9661
9662
9663SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *self, PyObject *args) {
9664 PyObject *resultobj = 0;
9665 PLFLT *arg1 = (PLFLT *) 0 ;
9666 PLFLT *arg2 = (PLFLT *) 0 ;
9667 PLFLT **arg3 = (PLFLT **) 0 ;
9668 PLINT arg4 ;
9669 PLINT arg5 ;
9670 PLINT arg6 ;
9671 PLFLT *arg7 = (PLFLT *) 0 ;
9672 PLINT arg8 ;
9673 PyArrayObject *tmp1 = NULL ;
9674 PyArrayObject *tmp2 = NULL ;
9675 PyArrayObject *tmp3 = NULL ;
9676 int val6 ;
9677 int ecode6 = 0 ;
9678 PyArrayObject *tmp7 = NULL ;
9679 PyObject *swig_obj[5] ;
9680
9681 (void)self;
9682 if (!SWIG_Python_UnpackTuple(args, "plsurf3d", 5, 5, swig_obj)) SWIG_fail;
9683 {
9684 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9685 if ( tmp1 == NULL )
9686 return NULL;
9687 Xlen = PyArray_DIMS( tmp1 )[0];
9688 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9689 }
9690 {
9691 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9692 if ( tmp2 == NULL )
9693 return NULL;
9694 Ylen = PyArray_DIMS( tmp2 )[0];
9695 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9696 }
9697 {
9698 int i, size;
9699 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9700 if ( tmp3 == NULL )
9701 return NULL;
9702 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9703 {
9704 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9705 return NULL;
9706 }
9707 arg4 = PyArray_DIMS( tmp3 )[0];
9708 arg5 = PyArray_DIMS( tmp3 )[1];
9709 size = arg5;
9710 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9711 for ( i = 0; i < arg4; i++ )
9712 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9713 }
9714 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9715 if (!SWIG_IsOK(ecode6)) {
9716 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9717 }
9718 arg6 = (PLINT)(val6);
9719 {
9720 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9721 if ( tmp7 == NULL )
9722 return NULL;
9723 arg8 = PyArray_DIMS( tmp7 )[0];
9724 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9725 }
9726 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9727 resultobj = SWIG_Py_Void();
9728 {
9729 Py_CLEAR( tmp1 );
9730 }
9731 {
9732 Py_CLEAR( tmp2 );
9733 }
9734 {
9735 Py_CLEAR( tmp3 );
9736 free( arg3 );
9737 }
9738 {
9739 Py_CLEAR( tmp7 );
9740 }
9741 return resultobj;
9742fail:
9743 {
9744 Py_CLEAR( tmp1 );
9745 }
9746 {
9747 Py_CLEAR( tmp2 );
9748 }
9749 {
9750 Py_CLEAR( tmp3 );
9751 free( arg3 );
9752 }
9753 {
9754 Py_CLEAR( tmp7 );
9755 }
9756 return NULL;
9757}
9758
9759
9760SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *self, PyObject *args) {
9761 PyObject *resultobj = 0;
9762 PLFLT *arg1 = (PLFLT *) 0 ;
9763 PLFLT *arg2 = (PLFLT *) 0 ;
9764 PLFLT **arg3 = (PLFLT **) 0 ;
9765 PLINT arg4 ;
9766 PLINT arg5 ;
9767 PLINT arg6 ;
9768 PLFLT *arg7 = (PLFLT *) 0 ;
9769 PLINT arg8 ;
9770 PLINT arg9 ;
9771 PLINT arg10 ;
9772 PLINT *arg11 = (PLINT *) 0 ;
9773 PLINT *arg12 = (PLINT *) 0 ;
9774 PyArrayObject *tmp1 = NULL ;
9775 PyArrayObject *tmp2 = NULL ;
9776 PyArrayObject *tmp3 = NULL ;
9777 int val6 ;
9778 int ecode6 = 0 ;
9779 PyArrayObject *tmp7 = NULL ;
9780 int val9 ;
9781 int ecode9 = 0 ;
9782 PyArrayObject *tmp10 = NULL ;
9783 PyArrayObject *tmp12 = NULL ;
9784 PyObject *swig_obj[8] ;
9785
9786 (void)self;
9787 if (!SWIG_Python_UnpackTuple(args, "plsurf3dl", 8, 8, swig_obj)) SWIG_fail;
9788 {
9789 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9790 if ( tmp1 == NULL )
9791 return NULL;
9792 Xlen = PyArray_DIMS( tmp1 )[0];
9793 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9794 }
9795 {
9796 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9797 if ( tmp2 == NULL )
9798 return NULL;
9799 Ylen = PyArray_DIMS( tmp2 )[0];
9800 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9801 }
9802 {
9803 int i, size;
9804 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9805 if ( tmp3 == NULL )
9806 return NULL;
9807 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9808 {
9809 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9810 return NULL;
9811 }
9812 arg4 = PyArray_DIMS( tmp3 )[0];
9813 arg5 = PyArray_DIMS( tmp3 )[1];
9814 size = arg5;
9815 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9816 for ( i = 0; i < arg4; i++ )
9817 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9818 }
9819 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9820 if (!SWIG_IsOK(ecode6)) {
9821 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9822 }
9823 arg6 = (PLINT)(val6);
9824 {
9825 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9826 if ( tmp7 == NULL )
9827 return NULL;
9828 arg8 = PyArray_DIMS( tmp7 )[0];
9829 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9830 }
9831 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9832 if (!SWIG_IsOK(ecode9)) {
9833 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9834 }
9835 arg9 = (PLINT)(val9);
9836 {
9837 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9838 if ( tmp10 == NULL )
9839 return NULL;
9840 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9841 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9842 }
9843 {
9844 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9845 if ( tmp12 == NULL )
9846 return NULL;
9847 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9848 {
9849 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9850 return NULL;
9851 }
9852 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9853 }
9854 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);
9855 resultobj = SWIG_Py_Void();
9856 {
9857 Py_CLEAR( tmp1 );
9858 }
9859 {
9860 Py_CLEAR( tmp2 );
9861 }
9862 {
9863 Py_CLEAR( tmp3 );
9864 free( arg3 );
9865 }
9866 {
9867 Py_CLEAR( tmp7 );
9868 }
9869 {
9870 Py_CLEAR( tmp10 );
9871 }
9872 {
9873 Py_CLEAR( tmp12 );
9874 }
9875 return resultobj;
9876fail:
9877 {
9878 Py_CLEAR( tmp1 );
9879 }
9880 {
9881 Py_CLEAR( tmp2 );
9882 }
9883 {
9884 Py_CLEAR( tmp3 );
9885 free( arg3 );
9886 }
9887 {
9888 Py_CLEAR( tmp7 );
9889 }
9890 {
9891 Py_CLEAR( tmp10 );
9892 }
9893 {
9894 Py_CLEAR( tmp12 );
9895 }
9896 return NULL;
9897}
9898
9899
9900SWIGINTERN PyObject *_wrap_plparseopts(PyObject *self, PyObject *args) {
9901 PyObject *resultobj = 0;
9902 int *arg1 = (int *) 0 ;
9903 char **arg2 = (char **) 0 ;
9904 PLINT arg3 ;
9905 int tmp1 ;
9906 int val3 ;
9907 int ecode3 = 0 ;
9908 PyObject *swig_obj[2] ;
9909 PLINT result;
9910
9911 (void)self;
9912 if (!SWIG_Python_UnpackTuple(args, "plparseopts", 2, 2, swig_obj)) SWIG_fail;
9913 {
9914 int i;
9915 PyObject *unicode_string;
9916
9917 if ( !PyList_Check( swig_obj[0] ) )
9918 {
9919 PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9920 return NULL;
9921 }
9922 tmp1 = PyList_Size( swig_obj[0] );
9923 arg1 = &tmp1;
9924 arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9925 for ( i = 0; i < tmp1; i++ )
9926 {
9927 PyObject *s = PyList_GetItem( swig_obj[0], i );
9928 if ( PyString_Check( s ) )
9929 {
9930 arg2[i] = PyString_AsString( s );
9931 }
9932 else if ( PyUnicode_Check( s ) )
9933 {
9934 // unicode_string is never freed? memory leak here?
9935 unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9936 arg2[i] = PyBytes_AS_STRING( unicode_string );
9937 }
9938 else
9939 {
9940 free( arg2 );
9941 PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9942 return NULL;
9943 }
9944 }
9945 arg2[i] = 0;
9946 }
9947 ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
9948 if (!SWIG_IsOK(ecode3)) {
9949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9950 }
9951 arg3 = (PLINT)(val3);
9952 result = (PLINT)plparseopts(arg1,arg2,arg3);
9953 resultobj = SWIG_From_int((int)(result));
9954 {
9955 if ( arg2 )
9956 free( arg2 );
9957 }
9958 return resultobj;
9959fail:
9960 {
9961 if ( arg2 )
9962 free( arg2 );
9963 }
9964 return NULL;
9965}
9966
9967
9968SWIGINTERN PyObject *_wrap_plpat(PyObject *self, PyObject *args) {
9969 PyObject *resultobj = 0;
9970 PLINT arg1 ;
9971 PLINT *arg2 = (PLINT *) 0 ;
9972 PLINT *arg3 = (PLINT *) 0 ;
9973 PyArrayObject *tmp1 = NULL ;
9974 PyArrayObject *tmp3 = NULL ;
9975 PyObject *swig_obj[2] ;
9976
9977 (void)self;
9978 if (!SWIG_Python_UnpackTuple(args, "plpat", 2, 2, swig_obj)) SWIG_fail;
9979 {
9980 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
9981 if ( tmp1 == NULL )
9982 return NULL;
9983 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
9984 arg2 = (PLINT *) PyArray_DATA( tmp1 );
9985 }
9986 {
9987 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
9988 if ( tmp3 == NULL )
9989 return NULL;
9990 if ( PyArray_DIMS( tmp3 )[0] != Alen )
9991 {
9992 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9993 return NULL;
9994 }
9995 arg3 = (PLINT *) PyArray_DATA( tmp3 );
9996 }
9997 plpat(arg1,(int const *)arg2,(int const *)arg3);
9998 resultobj = SWIG_Py_Void();
9999 {
10000 Py_CLEAR( tmp1 );
10001 }
10002 {
10003 Py_CLEAR( tmp3 );
10004 }
10005 return resultobj;
10006fail:
10007 {
10008 Py_CLEAR( tmp1 );
10009 }
10010 {
10011 Py_CLEAR( tmp3 );
10012 }
10013 return NULL;
10014}
10015
10016
10017SWIGINTERN PyObject *_wrap_plpath(PyObject *self, PyObject *args) {
10018 PyObject *resultobj = 0;
10019 PLINT arg1 ;
10020 PLFLT arg2 ;
10021 PLFLT arg3 ;
10022 PLFLT arg4 ;
10023 PLFLT arg5 ;
10024 int val1 ;
10025 int ecode1 = 0 ;
10026 double val2 ;
10027 int ecode2 = 0 ;
10028 double val3 ;
10029 int ecode3 = 0 ;
10030 double val4 ;
10031 int ecode4 = 0 ;
10032 double val5 ;
10033 int ecode5 = 0 ;
10034 PyObject *swig_obj[5] ;
10035
10036 (void)self;
10037 if (!SWIG_Python_UnpackTuple(args, "plpath", 5, 5, swig_obj)) SWIG_fail;
10038 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10039 if (!SWIG_IsOK(ecode1)) {
10040 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
10041 }
10042 arg1 = (PLINT)(val1);
10043 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10044 if (!SWIG_IsOK(ecode2)) {
10045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
10046 }
10047 arg2 = (PLFLT)(val2);
10048 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10049 if (!SWIG_IsOK(ecode3)) {
10050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
10051 }
10052 arg3 = (PLFLT)(val3);
10053 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10054 if (!SWIG_IsOK(ecode4)) {
10055 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
10056 }
10057 arg4 = (PLFLT)(val4);
10058 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10059 if (!SWIG_IsOK(ecode5)) {
10060 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
10061 }
10062 arg5 = (PLFLT)(val5);
10063 plpath(arg1,arg2,arg3,arg4,arg5);
10064 resultobj = SWIG_Py_Void();
10065 return resultobj;
10066fail:
10067 return NULL;
10068}
10069
10070
10071SWIGINTERN PyObject *_wrap_plpoin(PyObject *self, PyObject *args) {
10072 PyObject *resultobj = 0;
10073 PLINT arg1 ;
10074 PLFLT *arg2 = (PLFLT *) 0 ;
10075 PLFLT *arg3 = (PLFLT *) 0 ;
10076 PLINT arg4 ;
10077 PyArrayObject *tmp1 = NULL ;
10078 PyArrayObject *tmp3 = NULL ;
10079 int val4 ;
10080 int ecode4 = 0 ;
10081 PyObject *swig_obj[3] ;
10082
10083 (void)self;
10084 if (!SWIG_Python_UnpackTuple(args, "plpoin", 3, 3, swig_obj)) SWIG_fail;
10085 {
10086 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10087 if ( tmp1 == NULL )
10088 return NULL;
10089 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10090 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10091 }
10092 {
10093 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10094 if ( tmp3 == NULL )
10095 return NULL;
10096 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10097 {
10098 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10099 return NULL;
10100 }
10101 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10102 }
10103 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
10104 if (!SWIG_IsOK(ecode4)) {
10105 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
10106 }
10107 arg4 = (PLINT)(val4);
10108 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
10109 resultobj = SWIG_Py_Void();
10110 {
10111 Py_CLEAR( tmp1 );
10112 }
10113 {
10114 Py_CLEAR( tmp3 );
10115 }
10116 return resultobj;
10117fail:
10118 {
10119 Py_CLEAR( tmp1 );
10120 }
10121 {
10122 Py_CLEAR( tmp3 );
10123 }
10124 return NULL;
10125}
10126
10127
10128SWIGINTERN PyObject *_wrap_plpoin3(PyObject *self, PyObject *args) {
10129 PyObject *resultobj = 0;
10130 PLINT arg1 ;
10131 PLFLT *arg2 = (PLFLT *) 0 ;
10132 PLFLT *arg3 = (PLFLT *) 0 ;
10133 PLFLT *arg4 = (PLFLT *) 0 ;
10134 PLINT arg5 ;
10135 PyArrayObject *tmp1 = NULL ;
10136 PyArrayObject *tmp3 = NULL ;
10137 PyArrayObject *tmp4 = NULL ;
10138 int val5 ;
10139 int ecode5 = 0 ;
10140 PyObject *swig_obj[4] ;
10141
10142 (void)self;
10143 if (!SWIG_Python_UnpackTuple(args, "plpoin3", 4, 4, swig_obj)) SWIG_fail;
10144 {
10145 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10146 if ( tmp1 == NULL )
10147 return NULL;
10148 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10149 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10150 }
10151 {
10152 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10153 if ( tmp3 == NULL )
10154 return NULL;
10155 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10156 {
10157 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10158 return NULL;
10159 }
10160 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10161 }
10162 {
10163 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10164 if ( tmp4 == NULL )
10165 return NULL;
10166 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10167 {
10168 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10169 return NULL;
10170 }
10171 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10172 }
10173 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
10174 if (!SWIG_IsOK(ecode5)) {
10175 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
10176 }
10177 arg5 = (PLINT)(val5);
10178 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
10179 resultobj = SWIG_Py_Void();
10180 {
10181 Py_CLEAR( tmp1 );
10182 }
10183 {
10184 Py_CLEAR( tmp3 );
10185 }
10186 {
10187 Py_CLEAR( tmp4 );
10188 }
10189 return resultobj;
10190fail:
10191 {
10192 Py_CLEAR( tmp1 );
10193 }
10194 {
10195 Py_CLEAR( tmp3 );
10196 }
10197 {
10198 Py_CLEAR( tmp4 );
10199 }
10200 return NULL;
10201}
10202
10203
10204SWIGINTERN PyObject *_wrap_plpoly3(PyObject *self, PyObject *args) {
10205 PyObject *resultobj = 0;
10206 PLINT arg1 ;
10207 PLFLT *arg2 = (PLFLT *) 0 ;
10208 PLFLT *arg3 = (PLFLT *) 0 ;
10209 PLFLT *arg4 = (PLFLT *) 0 ;
10210 PLBOOL *arg5 = (PLBOOL *) 0 ;
10211 PLBOOL arg6 ;
10212 PyArrayObject *tmp1 = NULL ;
10213 PyArrayObject *tmp3 = NULL ;
10214 PyArrayObject *tmp4 = NULL ;
10215 PyArrayObject *tmp5 = NULL ;
10216 int val6 ;
10217 int ecode6 = 0 ;
10218 PyObject *swig_obj[5] ;
10219
10220 (void)self;
10221 if (!SWIG_Python_UnpackTuple(args, "plpoly3", 5, 5, swig_obj)) SWIG_fail;
10222 {
10223 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10224 if ( tmp1 == NULL )
10225 return NULL;
10226 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10227 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10228 }
10229 {
10230 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10231 if ( tmp3 == NULL )
10232 return NULL;
10233 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10234 {
10235 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10236 return NULL;
10237 }
10238 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10239 }
10240 {
10241 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10242 if ( tmp4 == NULL )
10243 return NULL;
10244 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10245 {
10246 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10247 return NULL;
10248 }
10249 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10250 }
10251 {
10252 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[3], NPY_PLINT, 1, 1 );
10253 if ( tmp5 == NULL )
10254 return NULL;
10255 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10256 {
10257 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10258 return NULL;
10259 }
10260 arg5 = (PLINT *) PyArray_DATA( tmp5 );
10261 }
10262 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
10263 if (!SWIG_IsOK(ecode6)) {
10264 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10265 }
10266 arg6 = (PLBOOL)(val6);
10267 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10268 resultobj = SWIG_Py_Void();
10269 {
10270 Py_CLEAR( tmp1 );
10271 }
10272 {
10273 Py_CLEAR( tmp3 );
10274 }
10275 {
10276 Py_CLEAR( tmp4 );
10277 }
10278 {
10279 Py_CLEAR( tmp5 );
10280 }
10281 return resultobj;
10282fail:
10283 {
10284 Py_CLEAR( tmp1 );
10285 }
10286 {
10287 Py_CLEAR( tmp3 );
10288 }
10289 {
10290 Py_CLEAR( tmp4 );
10291 }
10292 {
10293 Py_CLEAR( tmp5 );
10294 }
10295 return NULL;
10296}
10297
10298
10299SWIGINTERN PyObject *_wrap_plprec(PyObject *self, PyObject *args) {
10300 PyObject *resultobj = 0;
10301 PLINT arg1 ;
10302 PLINT arg2 ;
10303 int val1 ;
10304 int ecode1 = 0 ;
10305 int val2 ;
10306 int ecode2 = 0 ;
10307 PyObject *swig_obj[2] ;
10308
10309 (void)self;
10310 if (!SWIG_Python_UnpackTuple(args, "plprec", 2, 2, swig_obj)) SWIG_fail;
10311 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10312 if (!SWIG_IsOK(ecode1)) {
10313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10314 }
10315 arg1 = (PLINT)(val1);
10316 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10317 if (!SWIG_IsOK(ecode2)) {
10318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10319 }
10320 arg2 = (PLINT)(val2);
10321 plprec(arg1,arg2);
10322 resultobj = SWIG_Py_Void();
10323 return resultobj;
10324fail:
10325 return NULL;
10326}
10327
10328
10329SWIGINTERN PyObject *_wrap_plpsty(PyObject *self, PyObject *args) {
10330 PyObject *resultobj = 0;
10331 PLINT arg1 ;
10332 int val1 ;
10333 int ecode1 = 0 ;
10334 PyObject *swig_obj[1] ;
10335
10336 (void)self;
10337 if (!args) SWIG_fail;
10338 swig_obj[0] = args;
10339 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10340 if (!SWIG_IsOK(ecode1)) {
10341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10342 }
10343 arg1 = (PLINT)(val1);
10344 plpsty(arg1);
10345 resultobj = SWIG_Py_Void();
10346 return resultobj;
10347fail:
10348 return NULL;
10349}
10350
10351
10352SWIGINTERN PyObject *_wrap_plptex(PyObject *self, PyObject *args) {
10353 PyObject *resultobj = 0;
10354 PLFLT arg1 ;
10355 PLFLT arg2 ;
10356 PLFLT arg3 ;
10357 PLFLT arg4 ;
10358 PLFLT arg5 ;
10359 char *arg6 = (char *) 0 ;
10360 double val1 ;
10361 int ecode1 = 0 ;
10362 double val2 ;
10363 int ecode2 = 0 ;
10364 double val3 ;
10365 int ecode3 = 0 ;
10366 double val4 ;
10367 int ecode4 = 0 ;
10368 double val5 ;
10369 int ecode5 = 0 ;
10370 int res6 ;
10371 char *buf6 = 0 ;
10372 int alloc6 = 0 ;
10373 PyObject *swig_obj[6] ;
10374
10375 (void)self;
10376 if (!SWIG_Python_UnpackTuple(args, "plptex", 6, 6, swig_obj)) SWIG_fail;
10377 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10378 if (!SWIG_IsOK(ecode1)) {
10379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10380 }
10381 arg1 = (PLFLT)(val1);
10382 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10383 if (!SWIG_IsOK(ecode2)) {
10384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10385 }
10386 arg2 = (PLFLT)(val2);
10387 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10388 if (!SWIG_IsOK(ecode3)) {
10389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10390 }
10391 arg3 = (PLFLT)(val3);
10392 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10393 if (!SWIG_IsOK(ecode4)) {
10394 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10395 }
10396 arg4 = (PLFLT)(val4);
10397 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10398 if (!SWIG_IsOK(ecode5)) {
10399 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10400 }
10401 arg5 = (PLFLT)(val5);
10402 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
10403 if (!SWIG_IsOK(res6)) {
10404 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10405 }
10406 arg6 = (char *)(buf6);
10407 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10408 resultobj = SWIG_Py_Void();
10409 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10410 return resultobj;
10411fail:
10412 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10413 return NULL;
10414}
10415
10416
10417SWIGINTERN PyObject *_wrap_plptex3(PyObject *self, PyObject *args) {
10418 PyObject *resultobj = 0;
10419 PLFLT arg1 ;
10420 PLFLT arg2 ;
10421 PLFLT arg3 ;
10422 PLFLT arg4 ;
10423 PLFLT arg5 ;
10424 PLFLT arg6 ;
10425 PLFLT arg7 ;
10426 PLFLT arg8 ;
10427 PLFLT arg9 ;
10428 PLFLT arg10 ;
10429 char *arg11 = (char *) 0 ;
10430 double val1 ;
10431 int ecode1 = 0 ;
10432 double val2 ;
10433 int ecode2 = 0 ;
10434 double val3 ;
10435 int ecode3 = 0 ;
10436 double val4 ;
10437 int ecode4 = 0 ;
10438 double val5 ;
10439 int ecode5 = 0 ;
10440 double val6 ;
10441 int ecode6 = 0 ;
10442 double val7 ;
10443 int ecode7 = 0 ;
10444 double val8 ;
10445 int ecode8 = 0 ;
10446 double val9 ;
10447 int ecode9 = 0 ;
10448 double val10 ;
10449 int ecode10 = 0 ;
10450 int res11 ;
10451 char *buf11 = 0 ;
10452 int alloc11 = 0 ;
10453 PyObject *swig_obj[11] ;
10454
10455 (void)self;
10456 if (!SWIG_Python_UnpackTuple(args, "plptex3", 11, 11, swig_obj)) SWIG_fail;
10457 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10458 if (!SWIG_IsOK(ecode1)) {
10459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10460 }
10461 arg1 = (PLFLT)(val1);
10462 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10463 if (!SWIG_IsOK(ecode2)) {
10464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10465 }
10466 arg2 = (PLFLT)(val2);
10467 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10468 if (!SWIG_IsOK(ecode3)) {
10469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10470 }
10471 arg3 = (PLFLT)(val3);
10472 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10473 if (!SWIG_IsOK(ecode4)) {
10474 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10475 }
10476 arg4 = (PLFLT)(val4);
10477 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10478 if (!SWIG_IsOK(ecode5)) {
10479 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10480 }
10481 arg5 = (PLFLT)(val5);
10482 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
10483 if (!SWIG_IsOK(ecode6)) {
10484 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10485 }
10486 arg6 = (PLFLT)(val6);
10487 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
10488 if (!SWIG_IsOK(ecode7)) {
10489 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10490 }
10491 arg7 = (PLFLT)(val7);
10492 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
10493 if (!SWIG_IsOK(ecode8)) {
10494 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10495 }
10496 arg8 = (PLFLT)(val8);
10497 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
10498 if (!SWIG_IsOK(ecode9)) {
10499 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10500 }
10501 arg9 = (PLFLT)(val9);
10502 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
10503 if (!SWIG_IsOK(ecode10)) {
10504 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10505 }
10506 arg10 = (PLFLT)(val10);
10507 res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
10508 if (!SWIG_IsOK(res11)) {
10509 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10510 }
10511 arg11 = (char *)(buf11);
10512 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10513 resultobj = SWIG_Py_Void();
10514 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10515 return resultobj;
10516fail:
10517 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10518 return NULL;
10519}
10520
10521
10522SWIGINTERN PyObject *_wrap_plrandd(PyObject *self, PyObject *args) {
10523 PyObject *resultobj = 0;
10524 PLFLT result;
10525
10526 (void)self;
10527 if (!SWIG_Python_UnpackTuple(args, "plrandd", 0, 0, 0)) SWIG_fail;
10528 result = (PLFLT)plrandd();
10529 resultobj = SWIG_From_double((double)(result));
10530 return resultobj;
10531fail:
10532 return NULL;
10533}
10534
10535
10536SWIGINTERN PyObject *_wrap_plreplot(PyObject *self, PyObject *args) {
10537 PyObject *resultobj = 0;
10538
10539 (void)self;
10540 if (!SWIG_Python_UnpackTuple(args, "plreplot", 0, 0, 0)) SWIG_fail;
10541 plreplot();
10542 resultobj = SWIG_Py_Void();
10543 return resultobj;
10544fail:
10545 return NULL;
10546}
10547
10548
10549SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *self, PyObject *args) {
10550 PyObject *resultobj = 0;
10551 PLFLT arg1 ;
10552 PLFLT arg2 ;
10553 PLFLT arg3 ;
10554 PLFLT *arg4 = (PLFLT *) 0 ;
10555 PLFLT *arg5 = (PLFLT *) 0 ;
10556 PLFLT *arg6 = (PLFLT *) 0 ;
10557 double val1 ;
10558 int ecode1 = 0 ;
10559 double val2 ;
10560 int ecode2 = 0 ;
10561 double val3 ;
10562 int ecode3 = 0 ;
10563 PLFLT temp4 ;
10564 int res4 = SWIG_TMPOBJ ;
10565 PLFLT temp5 ;
10566 int res5 = SWIG_TMPOBJ ;
10567 PLFLT temp6 ;
10568 int res6 = SWIG_TMPOBJ ;
10569 PyObject *swig_obj[3] ;
10570
10571 arg4 = &temp4;
10572 arg5 = &temp5;
10573 arg6 = &temp6;
10574 (void)self;
10575 if (!SWIG_Python_UnpackTuple(args, "plrgbhls", 3, 3, swig_obj)) SWIG_fail;
10576 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10577 if (!SWIG_IsOK(ecode1)) {
10578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10579 }
10580 arg1 = (PLFLT)(val1);
10581 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10582 if (!SWIG_IsOK(ecode2)) {
10583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10584 }
10585 arg2 = (PLFLT)(val2);
10586 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10587 if (!SWIG_IsOK(ecode3)) {
10588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10589 }
10590 arg3 = (PLFLT)(val3);
10591 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10592 resultobj = SWIG_Py_Void();
10593 if (SWIG_IsTmpObj(res4)) {
10594 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
10595 } else {
10596 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10597 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
10598 }
10599 if (SWIG_IsTmpObj(res5)) {
10600 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
10601 } else {
10602 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10603 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
10604 }
10605 if (SWIG_IsTmpObj(res6)) {
10606 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
10607 } else {
10608 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10609 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
10610 }
10611 return resultobj;
10612fail:
10613 return NULL;
10614}
10615
10616
10617SWIGINTERN PyObject *_wrap_plschr(PyObject *self, PyObject *args) {
10618 PyObject *resultobj = 0;
10619 PLFLT arg1 ;
10620 PLFLT arg2 ;
10621 double val1 ;
10622 int ecode1 = 0 ;
10623 double val2 ;
10624 int ecode2 = 0 ;
10625 PyObject *swig_obj[2] ;
10626
10627 (void)self;
10628 if (!SWIG_Python_UnpackTuple(args, "plschr", 2, 2, swig_obj)) SWIG_fail;
10629 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10630 if (!SWIG_IsOK(ecode1)) {
10631 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10632 }
10633 arg1 = (PLFLT)(val1);
10634 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10635 if (!SWIG_IsOK(ecode2)) {
10636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10637 }
10638 arg2 = (PLFLT)(val2);
10639 plschr(arg1,arg2);
10640 resultobj = SWIG_Py_Void();
10641 return resultobj;
10642fail:
10643 return NULL;
10644}
10645
10646
10647SWIGINTERN PyObject *_wrap_plscmap0(PyObject *self, PyObject *args) {
10648 PyObject *resultobj = 0;
10649 PLINT *arg1 = (PLINT *) 0 ;
10650 PLINT *arg2 = (PLINT *) 0 ;
10651 PLINT *arg3 = (PLINT *) 0 ;
10652 PLINT arg4 ;
10653 PyArrayObject *tmp1 = NULL ;
10654 PyArrayObject *tmp2 = NULL ;
10655 PyArrayObject *tmp3 = NULL ;
10656 PyObject *swig_obj[3] ;
10657
10658 (void)self;
10659 if (!SWIG_Python_UnpackTuple(args, "plscmap0", 3, 3, swig_obj)) SWIG_fail;
10660 {
10661 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10662 if ( tmp1 == NULL )
10663 return NULL;
10664 Alen = PyArray_DIMS( tmp1 )[0];
10665 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10666 }
10667 {
10668 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10669 if ( tmp2 == NULL )
10670 return NULL;
10671 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10672 {
10673 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10674 return NULL;
10675 }
10676 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10677 }
10678 {
10679 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10680 if ( tmp3 == NULL )
10681 return NULL;
10682 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10683 {
10684 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10685 return NULL;
10686 }
10687 arg4 = PyArray_DIMS( tmp3 )[0];
10688 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10689 }
10690 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10691 resultobj = SWIG_Py_Void();
10692 {
10693 Py_CLEAR( tmp1 );
10694 }
10695 {
10696 Py_CLEAR( tmp2 );
10697 }
10698 {
10699 Py_CLEAR( tmp3 );
10700 }
10701 return resultobj;
10702fail:
10703 {
10704 Py_CLEAR( tmp1 );
10705 }
10706 {
10707 Py_CLEAR( tmp2 );
10708 }
10709 {
10710 Py_CLEAR( tmp3 );
10711 }
10712 return NULL;
10713}
10714
10715
10716SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *self, PyObject *args) {
10717 PyObject *resultobj = 0;
10718 PLINT *arg1 = (PLINT *) 0 ;
10719 PLINT *arg2 = (PLINT *) 0 ;
10720 PLINT *arg3 = (PLINT *) 0 ;
10721 PLFLT *arg4 = (PLFLT *) 0 ;
10722 PLINT arg5 ;
10723 PyArrayObject *tmp1 = NULL ;
10724 PyArrayObject *tmp2 = NULL ;
10725 PyArrayObject *tmp3 = NULL ;
10726 PyArrayObject *tmp4 = NULL ;
10727 PyObject *swig_obj[4] ;
10728
10729 (void)self;
10730 if (!SWIG_Python_UnpackTuple(args, "plscmap0a", 4, 4, swig_obj)) SWIG_fail;
10731 {
10732 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10733 if ( tmp1 == NULL )
10734 return NULL;
10735 Alen = PyArray_DIMS( tmp1 )[0];
10736 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10737 }
10738 {
10739 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10740 if ( tmp2 == NULL )
10741 return NULL;
10742 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10743 {
10744 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10745 return NULL;
10746 }
10747 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10748 }
10749 {
10750 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10751 if ( tmp3 == NULL )
10752 return NULL;
10753 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10754 {
10755 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10756 return NULL;
10757 }
10758 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10759 }
10760 {
10761 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10762 if ( tmp4 == NULL )
10763 return NULL;
10764 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10765 {
10766 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10767 return NULL;
10768 }
10769 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10770 arg5 = PyArray_DIMS( tmp4 )[0];
10771 }
10772 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10773 resultobj = SWIG_Py_Void();
10774 {
10775 Py_CLEAR( tmp1 );
10776 }
10777 {
10778 Py_CLEAR( tmp2 );
10779 }
10780 {
10781 Py_CLEAR( tmp3 );
10782 }
10783 {
10784 Py_CLEAR( tmp4 );
10785 }
10786 return resultobj;
10787fail:
10788 {
10789 Py_CLEAR( tmp1 );
10790 }
10791 {
10792 Py_CLEAR( tmp2 );
10793 }
10794 {
10795 Py_CLEAR( tmp3 );
10796 }
10797 {
10798 Py_CLEAR( tmp4 );
10799 }
10800 return NULL;
10801}
10802
10803
10804SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *self, PyObject *args) {
10805 PyObject *resultobj = 0;
10806 PLINT arg1 ;
10807 int val1 ;
10808 int ecode1 = 0 ;
10809 PyObject *swig_obj[1] ;
10810
10811 (void)self;
10812 if (!args) SWIG_fail;
10813 swig_obj[0] = args;
10814 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10815 if (!SWIG_IsOK(ecode1)) {
10816 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10817 }
10818 arg1 = (PLINT)(val1);
10819 plscmap0n(arg1);
10820 resultobj = SWIG_Py_Void();
10821 return resultobj;
10822fail:
10823 return NULL;
10824}
10825
10826
10827SWIGINTERN PyObject *_wrap_plscmap1(PyObject *self, PyObject *args) {
10828 PyObject *resultobj = 0;
10829 PLINT *arg1 = (PLINT *) 0 ;
10830 PLINT *arg2 = (PLINT *) 0 ;
10831 PLINT *arg3 = (PLINT *) 0 ;
10832 PLINT arg4 ;
10833 PyArrayObject *tmp1 = NULL ;
10834 PyArrayObject *tmp2 = NULL ;
10835 PyArrayObject *tmp3 = NULL ;
10836 PyObject *swig_obj[3] ;
10837
10838 (void)self;
10839 if (!SWIG_Python_UnpackTuple(args, "plscmap1", 3, 3, swig_obj)) SWIG_fail;
10840 {
10841 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10842 if ( tmp1 == NULL )
10843 return NULL;
10844 Alen = PyArray_DIMS( tmp1 )[0];
10845 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10846 }
10847 {
10848 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10849 if ( tmp2 == NULL )
10850 return NULL;
10851 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10852 {
10853 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10854 return NULL;
10855 }
10856 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10857 }
10858 {
10859 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10860 if ( tmp3 == NULL )
10861 return NULL;
10862 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10863 {
10864 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10865 return NULL;
10866 }
10867 arg4 = PyArray_DIMS( tmp3 )[0];
10868 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10869 }
10870 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10871 resultobj = SWIG_Py_Void();
10872 {
10873 Py_CLEAR( tmp1 );
10874 }
10875 {
10876 Py_CLEAR( tmp2 );
10877 }
10878 {
10879 Py_CLEAR( tmp3 );
10880 }
10881 return resultobj;
10882fail:
10883 {
10884 Py_CLEAR( tmp1 );
10885 }
10886 {
10887 Py_CLEAR( tmp2 );
10888 }
10889 {
10890 Py_CLEAR( tmp3 );
10891 }
10892 return NULL;
10893}
10894
10895
10896SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *self, PyObject *args) {
10897 PyObject *resultobj = 0;
10898 PLINT *arg1 = (PLINT *) 0 ;
10899 PLINT *arg2 = (PLINT *) 0 ;
10900 PLINT *arg3 = (PLINT *) 0 ;
10901 PLFLT *arg4 = (PLFLT *) 0 ;
10902 PLINT arg5 ;
10903 PyArrayObject *tmp1 = NULL ;
10904 PyArrayObject *tmp2 = NULL ;
10905 PyArrayObject *tmp3 = NULL ;
10906 PyArrayObject *tmp4 = NULL ;
10907 PyObject *swig_obj[4] ;
10908
10909 (void)self;
10910 if (!SWIG_Python_UnpackTuple(args, "plscmap1a", 4, 4, swig_obj)) SWIG_fail;
10911 {
10912 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10913 if ( tmp1 == NULL )
10914 return NULL;
10915 Alen = PyArray_DIMS( tmp1 )[0];
10916 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10917 }
10918 {
10919 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10920 if ( tmp2 == NULL )
10921 return NULL;
10922 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10923 {
10924 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10925 return NULL;
10926 }
10927 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10928 }
10929 {
10930 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10931 if ( tmp3 == NULL )
10932 return NULL;
10933 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10934 {
10935 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10936 return NULL;
10937 }
10938 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10939 }
10940 {
10941 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10942 if ( tmp4 == NULL )
10943 return NULL;
10944 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10945 {
10946 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10947 return NULL;
10948 }
10949 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10950 arg5 = PyArray_DIMS( tmp4 )[0];
10951 }
10952 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10953 resultobj = SWIG_Py_Void();
10954 {
10955 Py_CLEAR( tmp1 );
10956 }
10957 {
10958 Py_CLEAR( tmp2 );
10959 }
10960 {
10961 Py_CLEAR( tmp3 );
10962 }
10963 {
10964 Py_CLEAR( tmp4 );
10965 }
10966 return resultobj;
10967fail:
10968 {
10969 Py_CLEAR( tmp1 );
10970 }
10971 {
10972 Py_CLEAR( tmp2 );
10973 }
10974 {
10975 Py_CLEAR( tmp3 );
10976 }
10977 {
10978 Py_CLEAR( tmp4 );
10979 }
10980 return NULL;
10981}
10982
10983
10984SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *self, PyObject *args) {
10985 PyObject *resultobj = 0;
10986 PLBOOL arg1 ;
10987 PLINT arg2 ;
10988 PLFLT *arg3 = (PLFLT *) 0 ;
10989 PLFLT *arg4 = (PLFLT *) 0 ;
10990 PLFLT *arg5 = (PLFLT *) 0 ;
10991 PLFLT *arg6 = (PLFLT *) 0 ;
10992 PLBOOL *arg7 = (PLBOOL *) 0 ;
10993 int val1 ;
10994 int ecode1 = 0 ;
10995 PyArrayObject *tmp2 = NULL ;
10996 PyArrayObject *tmp4 = NULL ;
10997 PyArrayObject *tmp5 = NULL ;
10998 PyArrayObject *tmp6 = NULL ;
10999 PyArrayObject *tmp7 = NULL ;
11000 PyObject *swig_obj[6] ;
11001
11002 (void)self;
11003 if (!SWIG_Python_UnpackTuple(args, "plscmap1l", 6, 6, swig_obj)) SWIG_fail;
11004 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11005 if (!SWIG_IsOK(ecode1)) {
11006 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
11007 }
11008 arg1 = (PLBOOL)(val1);
11009 {
11010 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11011 if ( tmp2 == NULL )
11012 return NULL;
11013 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11014 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11015 }
11016 {
11017 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11018 if ( tmp4 == NULL )
11019 return NULL;
11020 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11021 {
11022 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11023 return NULL;
11024 }
11025 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11026 }
11027 {
11028 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11029 if ( tmp5 == NULL )
11030 return NULL;
11031 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11032 {
11033 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11034 return NULL;
11035 }
11036 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11037 }
11038 {
11039 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11040 if ( tmp6 == NULL )
11041 return NULL;
11042 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11043 {
11044 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11045 return NULL;
11046 }
11047 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11048 }
11049 {
11050 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[5], NPY_PLINT, 1, 1 );
11051 if ( tmp7 == NULL )
11052 return NULL;
11053 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
11054 {
11055 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11056 return NULL;
11057 }
11058 arg7 = (PLINT *) PyArray_DATA( tmp7 );
11059 }
11060 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
11061 resultobj = SWIG_Py_Void();
11062 {
11063 Py_CLEAR( tmp2 );
11064 }
11065 {
11066 Py_CLEAR( tmp4 );
11067 }
11068 {
11069 Py_CLEAR( tmp5 );
11070 }
11071 {
11072 Py_CLEAR( tmp6 );
11073 }
11074 {
11075 Py_CLEAR( tmp7 );
11076 }
11077 return resultobj;
11078fail:
11079 {
11080 Py_CLEAR( tmp2 );
11081 }
11082 {
11083 Py_CLEAR( tmp4 );
11084 }
11085 {
11086 Py_CLEAR( tmp5 );
11087 }
11088 {
11089 Py_CLEAR( tmp6 );
11090 }
11091 {
11092 Py_CLEAR( tmp7 );
11093 }
11094 return NULL;
11095}
11096
11097
11098SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *self, PyObject *args) {
11099 PyObject *resultobj = 0;
11100 PLBOOL arg1 ;
11101 PLINT arg2 ;
11102 PLFLT *arg3 = (PLFLT *) 0 ;
11103 PLFLT *arg4 = (PLFLT *) 0 ;
11104 PLFLT *arg5 = (PLFLT *) 0 ;
11105 PLFLT *arg6 = (PLFLT *) 0 ;
11106 PLFLT *arg7 = (PLFLT *) 0 ;
11107 PLBOOL *arg8 = (PLBOOL *) 0 ;
11108 int val1 ;
11109 int ecode1 = 0 ;
11110 PyArrayObject *tmp2 = NULL ;
11111 PyArrayObject *tmp4 = NULL ;
11112 PyArrayObject *tmp5 = NULL ;
11113 PyArrayObject *tmp6 = NULL ;
11114 PyArrayObject *tmp7 = NULL ;
11115 PyArrayObject *tmp8 = NULL ;
11116 PyObject *swig_obj[7] ;
11117
11118 (void)self;
11119 if (!SWIG_Python_UnpackTuple(args, "plscmap1la", 7, 7, swig_obj)) SWIG_fail;
11120 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11121 if (!SWIG_IsOK(ecode1)) {
11122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
11123 }
11124 arg1 = (PLBOOL)(val1);
11125 {
11126 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11127 if ( tmp2 == NULL )
11128 return NULL;
11129 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11130 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11131 }
11132 {
11133 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11134 if ( tmp4 == NULL )
11135 return NULL;
11136 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11137 {
11138 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11139 return NULL;
11140 }
11141 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11142 }
11143 {
11144 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11145 if ( tmp5 == NULL )
11146 return NULL;
11147 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11148 {
11149 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11150 return NULL;
11151 }
11152 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11153 }
11154 {
11155 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11156 if ( tmp6 == NULL )
11157 return NULL;
11158 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11159 {
11160 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11161 return NULL;
11162 }
11163 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11164 }
11165 {
11166 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
11167 if ( tmp7 == NULL )
11168 return NULL;
11169 if ( PyArray_DIMS( tmp7 )[0] != Alen )
11170 {
11171 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11172 return NULL;
11173 }
11174 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
11175 }
11176 {
11177 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
11178 if ( tmp8 == NULL )
11179 return NULL;
11180 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
11181 {
11182 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11183 return NULL;
11184 }
11185 arg8 = (PLINT *) PyArray_DATA( tmp8 );
11186 }
11187 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
11188 resultobj = SWIG_Py_Void();
11189 {
11190 Py_CLEAR( tmp2 );
11191 }
11192 {
11193 Py_CLEAR( tmp4 );
11194 }
11195 {
11196 Py_CLEAR( tmp5 );
11197 }
11198 {
11199 Py_CLEAR( tmp6 );
11200 }
11201 {
11202 Py_CLEAR( tmp7 );
11203 }
11204 {
11205 Py_CLEAR( tmp8 );
11206 }
11207 return resultobj;
11208fail:
11209 {
11210 Py_CLEAR( tmp2 );
11211 }
11212 {
11213 Py_CLEAR( tmp4 );
11214 }
11215 {
11216 Py_CLEAR( tmp5 );
11217 }
11218 {
11219 Py_CLEAR( tmp6 );
11220 }
11221 {
11222 Py_CLEAR( tmp7 );
11223 }
11224 {
11225 Py_CLEAR( tmp8 );
11226 }
11227 return NULL;
11228}
11229
11230
11231SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *self, PyObject *args) {
11232 PyObject *resultobj = 0;
11233 PLINT arg1 ;
11234 int val1 ;
11235 int ecode1 = 0 ;
11236 PyObject *swig_obj[1] ;
11237
11238 (void)self;
11239 if (!args) SWIG_fail;
11240 swig_obj[0] = args;
11241 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11242 if (!SWIG_IsOK(ecode1)) {
11243 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11244 }
11245 arg1 = (PLINT)(val1);
11246 plscmap1n(arg1);
11247 resultobj = SWIG_Py_Void();
11248 return resultobj;
11249fail:
11250 return NULL;
11251}
11252
11253
11254SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *self, PyObject *args) {
11255 PyObject *resultobj = 0;
11256 PLFLT arg1 ;
11257 PLFLT arg2 ;
11258 double val1 ;
11259 int ecode1 = 0 ;
11260 double val2 ;
11261 int ecode2 = 0 ;
11262 PyObject *swig_obj[2] ;
11263
11264 (void)self;
11265 if (!SWIG_Python_UnpackTuple(args, "plscmap1_range", 2, 2, swig_obj)) SWIG_fail;
11266 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11267 if (!SWIG_IsOK(ecode1)) {
11268 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11269 }
11270 arg1 = (PLFLT)(val1);
11271 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11272 if (!SWIG_IsOK(ecode2)) {
11273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11274 }
11275 arg2 = (PLFLT)(val2);
11276 plscmap1_range(arg1,arg2);
11277 resultobj = SWIG_Py_Void();
11278 return resultobj;
11279fail:
11280 return NULL;
11281}
11282
11283
11284SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *self, PyObject *args) {
11285 PyObject *resultobj = 0;
11286 PLFLT *arg1 = (PLFLT *) 0 ;
11287 PLFLT *arg2 = (PLFLT *) 0 ;
11288 PLFLT temp1 ;
11289 int res1 = SWIG_TMPOBJ ;
11290 PLFLT temp2 ;
11291 int res2 = SWIG_TMPOBJ ;
11292
11293 arg1 = &temp1;
11294 arg2 = &temp2;
11295 (void)self;
11296 if (!SWIG_Python_UnpackTuple(args, "plgcmap1_range", 0, 0, 0)) SWIG_fail;
11297 plgcmap1_range(arg1,arg2);
11298 resultobj = SWIG_Py_Void();
11299 if (SWIG_IsTmpObj(res1)) {
11300 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)));
11301 } else {
11302 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11303 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11304 }
11305 if (SWIG_IsTmpObj(res2)) {
11306 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
11307 } else {
11308 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11309 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11310 }
11311 return resultobj;
11312fail:
11313 return NULL;
11314}
11315
11316
11317SWIGINTERN PyObject *_wrap_plscol0(PyObject *self, PyObject *args) {
11318 PyObject *resultobj = 0;
11319 PLINT arg1 ;
11320 PLINT arg2 ;
11321 PLINT arg3 ;
11322 PLINT arg4 ;
11323 int val1 ;
11324 int ecode1 = 0 ;
11325 int val2 ;
11326 int ecode2 = 0 ;
11327 int val3 ;
11328 int ecode3 = 0 ;
11329 int val4 ;
11330 int ecode4 = 0 ;
11331 PyObject *swig_obj[4] ;
11332
11333 (void)self;
11334 if (!SWIG_Python_UnpackTuple(args, "plscol0", 4, 4, swig_obj)) SWIG_fail;
11335 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11336 if (!SWIG_IsOK(ecode1)) {
11337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11338 }
11339 arg1 = (PLINT)(val1);
11340 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11341 if (!SWIG_IsOK(ecode2)) {
11342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11343 }
11344 arg2 = (PLINT)(val2);
11345 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11346 if (!SWIG_IsOK(ecode3)) {
11347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11348 }
11349 arg3 = (PLINT)(val3);
11350 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11351 if (!SWIG_IsOK(ecode4)) {
11352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11353 }
11354 arg4 = (PLINT)(val4);
11355 plscol0(arg1,arg2,arg3,arg4);
11356 resultobj = SWIG_Py_Void();
11357 return resultobj;
11358fail:
11359 return NULL;
11360}
11361
11362
11363SWIGINTERN PyObject *_wrap_plscol0a(PyObject *self, PyObject *args) {
11364 PyObject *resultobj = 0;
11365 PLINT arg1 ;
11366 PLINT arg2 ;
11367 PLINT arg3 ;
11368 PLINT arg4 ;
11369 PLFLT arg5 ;
11370 int val1 ;
11371 int ecode1 = 0 ;
11372 int val2 ;
11373 int ecode2 = 0 ;
11374 int val3 ;
11375 int ecode3 = 0 ;
11376 int val4 ;
11377 int ecode4 = 0 ;
11378 double val5 ;
11379 int ecode5 = 0 ;
11380 PyObject *swig_obj[5] ;
11381
11382 (void)self;
11383 if (!SWIG_Python_UnpackTuple(args, "plscol0a", 5, 5, swig_obj)) SWIG_fail;
11384 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11385 if (!SWIG_IsOK(ecode1)) {
11386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11387 }
11388 arg1 = (PLINT)(val1);
11389 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11390 if (!SWIG_IsOK(ecode2)) {
11391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11392 }
11393 arg2 = (PLINT)(val2);
11394 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11395 if (!SWIG_IsOK(ecode3)) {
11396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11397 }
11398 arg3 = (PLINT)(val3);
11399 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11400 if (!SWIG_IsOK(ecode4)) {
11401 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11402 }
11403 arg4 = (PLINT)(val4);
11404 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11405 if (!SWIG_IsOK(ecode5)) {
11406 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11407 }
11408 arg5 = (PLFLT)(val5);
11409 plscol0a(arg1,arg2,arg3,arg4,arg5);
11410 resultobj = SWIG_Py_Void();
11411 return resultobj;
11412fail:
11413 return NULL;
11414}
11415
11416
11417SWIGINTERN PyObject *_wrap_plscolbg(PyObject *self, PyObject *args) {
11418 PyObject *resultobj = 0;
11419 PLINT arg1 ;
11420 PLINT arg2 ;
11421 PLINT arg3 ;
11422 int val1 ;
11423 int ecode1 = 0 ;
11424 int val2 ;
11425 int ecode2 = 0 ;
11426 int val3 ;
11427 int ecode3 = 0 ;
11428 PyObject *swig_obj[3] ;
11429
11430 (void)self;
11431 if (!SWIG_Python_UnpackTuple(args, "plscolbg", 3, 3, swig_obj)) SWIG_fail;
11432 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11433 if (!SWIG_IsOK(ecode1)) {
11434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11435 }
11436 arg1 = (PLINT)(val1);
11437 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11438 if (!SWIG_IsOK(ecode2)) {
11439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11440 }
11441 arg2 = (PLINT)(val2);
11442 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11443 if (!SWIG_IsOK(ecode3)) {
11444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11445 }
11446 arg3 = (PLINT)(val3);
11447 plscolbg(arg1,arg2,arg3);
11448 resultobj = SWIG_Py_Void();
11449 return resultobj;
11450fail:
11451 return NULL;
11452}
11453
11454
11455SWIGINTERN PyObject *_wrap_plscolbga(PyObject *self, PyObject *args) {
11456 PyObject *resultobj = 0;
11457 PLINT arg1 ;
11458 PLINT arg2 ;
11459 PLINT arg3 ;
11460 PLFLT arg4 ;
11461 int val1 ;
11462 int ecode1 = 0 ;
11463 int val2 ;
11464 int ecode2 = 0 ;
11465 int val3 ;
11466 int ecode3 = 0 ;
11467 double val4 ;
11468 int ecode4 = 0 ;
11469 PyObject *swig_obj[4] ;
11470
11471 (void)self;
11472 if (!SWIG_Python_UnpackTuple(args, "plscolbga", 4, 4, swig_obj)) SWIG_fail;
11473 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11474 if (!SWIG_IsOK(ecode1)) {
11475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11476 }
11477 arg1 = (PLINT)(val1);
11478 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11479 if (!SWIG_IsOK(ecode2)) {
11480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11481 }
11482 arg2 = (PLINT)(val2);
11483 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11484 if (!SWIG_IsOK(ecode3)) {
11485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11486 }
11487 arg3 = (PLINT)(val3);
11488 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11489 if (!SWIG_IsOK(ecode4)) {
11490 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11491 }
11492 arg4 = (PLFLT)(val4);
11493 plscolbga(arg1,arg2,arg3,arg4);
11494 resultobj = SWIG_Py_Void();
11495 return resultobj;
11496fail:
11497 return NULL;
11498}
11499
11500
11501SWIGINTERN PyObject *_wrap_plscolor(PyObject *self, PyObject *args) {
11502 PyObject *resultobj = 0;
11503 PLINT arg1 ;
11504 int val1 ;
11505 int ecode1 = 0 ;
11506 PyObject *swig_obj[1] ;
11507
11508 (void)self;
11509 if (!args) SWIG_fail;
11510 swig_obj[0] = args;
11511 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11512 if (!SWIG_IsOK(ecode1)) {
11513 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11514 }
11515 arg1 = (PLINT)(val1);
11516 plscolor(arg1);
11517 resultobj = SWIG_Py_Void();
11518 return resultobj;
11519fail:
11520 return NULL;
11521}
11522
11523
11524SWIGINTERN PyObject *_wrap_plscompression(PyObject *self, PyObject *args) {
11525 PyObject *resultobj = 0;
11526 PLINT arg1 ;
11527 int val1 ;
11528 int ecode1 = 0 ;
11529 PyObject *swig_obj[1] ;
11530
11531 (void)self;
11532 if (!args) SWIG_fail;
11533 swig_obj[0] = args;
11534 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11535 if (!SWIG_IsOK(ecode1)) {
11536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11537 }
11538 arg1 = (PLINT)(val1);
11539 plscompression(arg1);
11540 resultobj = SWIG_Py_Void();
11541 return resultobj;
11542fail:
11543 return NULL;
11544}
11545
11546
11547SWIGINTERN PyObject *_wrap_plsdev(PyObject *self, PyObject *args) {
11548 PyObject *resultobj = 0;
11549 char *arg1 = (char *) 0 ;
11550 int res1 ;
11551 char *buf1 = 0 ;
11552 int alloc1 = 0 ;
11553 PyObject *swig_obj[1] ;
11554
11555 (void)self;
11556 if (!args) SWIG_fail;
11557 swig_obj[0] = args;
11558 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11559 if (!SWIG_IsOK(res1)) {
11560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11561 }
11562 arg1 = (char *)(buf1);
11563 plsdev((char const *)arg1);
11564 resultobj = SWIG_Py_Void();
11565 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11566 return resultobj;
11567fail:
11568 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11569 return NULL;
11570}
11571
11572
11573SWIGINTERN PyObject *_wrap_plsdidev(PyObject *self, PyObject *args) {
11574 PyObject *resultobj = 0;
11575 PLFLT arg1 ;
11576 PLFLT arg2 ;
11577 PLFLT arg3 ;
11578 PLFLT arg4 ;
11579 double val1 ;
11580 int ecode1 = 0 ;
11581 double val2 ;
11582 int ecode2 = 0 ;
11583 double val3 ;
11584 int ecode3 = 0 ;
11585 double val4 ;
11586 int ecode4 = 0 ;
11587 PyObject *swig_obj[4] ;
11588
11589 (void)self;
11590 if (!SWIG_Python_UnpackTuple(args, "plsdidev", 4, 4, swig_obj)) SWIG_fail;
11591 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11592 if (!SWIG_IsOK(ecode1)) {
11593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11594 }
11595 arg1 = (PLFLT)(val1);
11596 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11597 if (!SWIG_IsOK(ecode2)) {
11598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11599 }
11600 arg2 = (PLFLT)(val2);
11601 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11602 if (!SWIG_IsOK(ecode3)) {
11603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11604 }
11605 arg3 = (PLFLT)(val3);
11606 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11607 if (!SWIG_IsOK(ecode4)) {
11608 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11609 }
11610 arg4 = (PLFLT)(val4);
11611 plsdidev(arg1,arg2,arg3,arg4);
11612 resultobj = SWIG_Py_Void();
11613 return resultobj;
11614fail:
11615 return NULL;
11616}
11617
11618
11619SWIGINTERN PyObject *_wrap_plsdimap(PyObject *self, PyObject *args) {
11620 PyObject *resultobj = 0;
11621 PLINT arg1 ;
11622 PLINT arg2 ;
11623 PLINT arg3 ;
11624 PLINT arg4 ;
11625 PLFLT arg5 ;
11626 PLFLT arg6 ;
11627 int val1 ;
11628 int ecode1 = 0 ;
11629 int val2 ;
11630 int ecode2 = 0 ;
11631 int val3 ;
11632 int ecode3 = 0 ;
11633 int val4 ;
11634 int ecode4 = 0 ;
11635 double val5 ;
11636 int ecode5 = 0 ;
11637 double val6 ;
11638 int ecode6 = 0 ;
11639 PyObject *swig_obj[6] ;
11640
11641 (void)self;
11642 if (!SWIG_Python_UnpackTuple(args, "plsdimap", 6, 6, swig_obj)) SWIG_fail;
11643 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11644 if (!SWIG_IsOK(ecode1)) {
11645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11646 }
11647 arg1 = (PLINT)(val1);
11648 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11649 if (!SWIG_IsOK(ecode2)) {
11650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11651 }
11652 arg2 = (PLINT)(val2);
11653 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11654 if (!SWIG_IsOK(ecode3)) {
11655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11656 }
11657 arg3 = (PLINT)(val3);
11658 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11659 if (!SWIG_IsOK(ecode4)) {
11660 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11661 }
11662 arg4 = (PLINT)(val4);
11663 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11664 if (!SWIG_IsOK(ecode5)) {
11665 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11666 }
11667 arg5 = (PLFLT)(val5);
11668 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
11669 if (!SWIG_IsOK(ecode6)) {
11670 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11671 }
11672 arg6 = (PLFLT)(val6);
11673 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11674 resultobj = SWIG_Py_Void();
11675 return resultobj;
11676fail:
11677 return NULL;
11678}
11679
11680
11681SWIGINTERN PyObject *_wrap_plsdiori(PyObject *self, PyObject *args) {
11682 PyObject *resultobj = 0;
11683 PLFLT arg1 ;
11684 double val1 ;
11685 int ecode1 = 0 ;
11686 PyObject *swig_obj[1] ;
11687
11688 (void)self;
11689 if (!args) SWIG_fail;
11690 swig_obj[0] = args;
11691 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11692 if (!SWIG_IsOK(ecode1)) {
11693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11694 }
11695 arg1 = (PLFLT)(val1);
11696 plsdiori(arg1);
11697 resultobj = SWIG_Py_Void();
11698 return resultobj;
11699fail:
11700 return NULL;
11701}
11702
11703
11704SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *self, PyObject *args) {
11705 PyObject *resultobj = 0;
11706 PLFLT arg1 ;
11707 PLFLT arg2 ;
11708 PLFLT arg3 ;
11709 PLFLT arg4 ;
11710 double val1 ;
11711 int ecode1 = 0 ;
11712 double val2 ;
11713 int ecode2 = 0 ;
11714 double val3 ;
11715 int ecode3 = 0 ;
11716 double val4 ;
11717 int ecode4 = 0 ;
11718 PyObject *swig_obj[4] ;
11719
11720 (void)self;
11721 if (!SWIG_Python_UnpackTuple(args, "plsdiplt", 4, 4, swig_obj)) SWIG_fail;
11722 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11723 if (!SWIG_IsOK(ecode1)) {
11724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11725 }
11726 arg1 = (PLFLT)(val1);
11727 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11728 if (!SWIG_IsOK(ecode2)) {
11729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11730 }
11731 arg2 = (PLFLT)(val2);
11732 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11733 if (!SWIG_IsOK(ecode3)) {
11734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11735 }
11736 arg3 = (PLFLT)(val3);
11737 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11738 if (!SWIG_IsOK(ecode4)) {
11739 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11740 }
11741 arg4 = (PLFLT)(val4);
11742 plsdiplt(arg1,arg2,arg3,arg4);
11743 resultobj = SWIG_Py_Void();
11744 return resultobj;
11745fail:
11746 return NULL;
11747}
11748
11749
11750SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *self, PyObject *args) {
11751 PyObject *resultobj = 0;
11752 PLFLT arg1 ;
11753 PLFLT arg2 ;
11754 PLFLT arg3 ;
11755 PLFLT arg4 ;
11756 double val1 ;
11757 int ecode1 = 0 ;
11758 double val2 ;
11759 int ecode2 = 0 ;
11760 double val3 ;
11761 int ecode3 = 0 ;
11762 double val4 ;
11763 int ecode4 = 0 ;
11764 PyObject *swig_obj[4] ;
11765
11766 (void)self;
11767 if (!SWIG_Python_UnpackTuple(args, "plsdiplz", 4, 4, swig_obj)) SWIG_fail;
11768 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11769 if (!SWIG_IsOK(ecode1)) {
11770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11771 }
11772 arg1 = (PLFLT)(val1);
11773 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11774 if (!SWIG_IsOK(ecode2)) {
11775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11776 }
11777 arg2 = (PLFLT)(val2);
11778 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11779 if (!SWIG_IsOK(ecode3)) {
11780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11781 }
11782 arg3 = (PLFLT)(val3);
11783 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11784 if (!SWIG_IsOK(ecode4)) {
11785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11786 }
11787 arg4 = (PLFLT)(val4);
11788 plsdiplz(arg1,arg2,arg3,arg4);
11789 resultobj = SWIG_Py_Void();
11790 return resultobj;
11791fail:
11792 return NULL;
11793}
11794
11795
11796SWIGINTERN PyObject *_wrap_plseed(PyObject *self, PyObject *args) {
11797 PyObject *resultobj = 0;
11798 unsigned int arg1 ;
11799 unsigned int val1 ;
11800 int ecode1 = 0 ;
11801 PyObject *swig_obj[1] ;
11802
11803 (void)self;
11804 if (!args) SWIG_fail;
11805 swig_obj[0] = args;
11806 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11807 if (!SWIG_IsOK(ecode1)) {
11808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11809 }
11810 arg1 = (unsigned int)(val1);
11811 plseed(arg1);
11812 resultobj = SWIG_Py_Void();
11813 return resultobj;
11814fail:
11815 return NULL;
11816}
11817
11818
11819SWIGINTERN PyObject *_wrap_plsesc(PyObject *self, PyObject *args) {
11820 PyObject *resultobj = 0;
11821 char arg1 ;
11822 char val1 ;
11823 int ecode1 = 0 ;
11824 PyObject *swig_obj[1] ;
11825
11826 (void)self;
11827 if (!args) SWIG_fail;
11828 swig_obj[0] = args;
11829 ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
11830 if (!SWIG_IsOK(ecode1)) {
11831 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11832 }
11833 arg1 = (char)(val1);
11834 plsesc(arg1);
11835 resultobj = SWIG_Py_Void();
11836 return resultobj;
11837fail:
11838 return NULL;
11839}
11840
11841
11842SWIGINTERN PyObject *_wrap_plsetopt(PyObject *self, PyObject *args) {
11843 PyObject *resultobj = 0;
11844 char *arg1 = (char *) 0 ;
11845 char *arg2 = (char *) 0 ;
11846 int res1 ;
11847 char *buf1 = 0 ;
11848 int alloc1 = 0 ;
11849 int res2 ;
11850 char *buf2 = 0 ;
11851 int alloc2 = 0 ;
11852 PyObject *swig_obj[2] ;
11853 PLINT result;
11854
11855 (void)self;
11856 if (!SWIG_Python_UnpackTuple(args, "plsetopt", 2, 2, swig_obj)) SWIG_fail;
11857 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11858 if (!SWIG_IsOK(res1)) {
11859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11860 }
11861 arg1 = (char *)(buf1);
11862 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11863 if (!SWIG_IsOK(res2)) {
11864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11865 }
11866 arg2 = (char *)(buf2);
11867 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11868 resultobj = SWIG_From_int((int)(result));
11869 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11870 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11871 return resultobj;
11872fail:
11873 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11874 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11875 return NULL;
11876}
11877
11878
11879SWIGINTERN PyObject *_wrap_plsfam(PyObject *self, PyObject *args) {
11880 PyObject *resultobj = 0;
11881 PLINT arg1 ;
11882 PLINT arg2 ;
11883 PLINT arg3 ;
11884 int val1 ;
11885 int ecode1 = 0 ;
11886 int val2 ;
11887 int ecode2 = 0 ;
11888 int val3 ;
11889 int ecode3 = 0 ;
11890 PyObject *swig_obj[3] ;
11891
11892 (void)self;
11893 if (!SWIG_Python_UnpackTuple(args, "plsfam", 3, 3, swig_obj)) SWIG_fail;
11894 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11895 if (!SWIG_IsOK(ecode1)) {
11896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11897 }
11898 arg1 = (PLINT)(val1);
11899 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11900 if (!SWIG_IsOK(ecode2)) {
11901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11902 }
11903 arg2 = (PLINT)(val2);
11904 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11905 if (!SWIG_IsOK(ecode3)) {
11906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11907 }
11908 arg3 = (PLINT)(val3);
11909 plsfam(arg1,arg2,arg3);
11910 resultobj = SWIG_Py_Void();
11911 return resultobj;
11912fail:
11913 return NULL;
11914}
11915
11916
11917SWIGINTERN PyObject *_wrap_plsfci(PyObject *self, PyObject *args) {
11918 PyObject *resultobj = 0;
11919 PLUNICODE arg1 ;
11920 unsigned int val1 ;
11921 int ecode1 = 0 ;
11922 PyObject *swig_obj[1] ;
11923
11924 (void)self;
11925 if (!args) SWIG_fail;
11926 swig_obj[0] = args;
11927 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11928 if (!SWIG_IsOK(ecode1)) {
11929 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11930 }
11931 arg1 = (PLUNICODE)(val1);
11932 plsfci(arg1);
11933 resultobj = SWIG_Py_Void();
11934 return resultobj;
11935fail:
11936 return NULL;
11937}
11938
11939
11940SWIGINTERN PyObject *_wrap_plsfnam(PyObject *self, PyObject *args) {
11941 PyObject *resultobj = 0;
11942 char *arg1 = (char *) 0 ;
11943 int res1 ;
11944 char *buf1 = 0 ;
11945 int alloc1 = 0 ;
11946 PyObject *swig_obj[1] ;
11947
11948 (void)self;
11949 if (!args) SWIG_fail;
11950 swig_obj[0] = args;
11951 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11952 if (!SWIG_IsOK(res1)) {
11953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11954 }
11955 arg1 = (char *)(buf1);
11956 plsfnam((char const *)arg1);
11957 resultobj = SWIG_Py_Void();
11958 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11959 return resultobj;
11960fail:
11961 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11962 return NULL;
11963}
11964
11965
11966SWIGINTERN PyObject *_wrap_plsfont(PyObject *self, PyObject *args) {
11967 PyObject *resultobj = 0;
11968 PLINT arg1 ;
11969 PLINT arg2 ;
11970 PLINT arg3 ;
11971 int val1 ;
11972 int ecode1 = 0 ;
11973 int val2 ;
11974 int ecode2 = 0 ;
11975 int val3 ;
11976 int ecode3 = 0 ;
11977 PyObject *swig_obj[3] ;
11978
11979 (void)self;
11980 if (!SWIG_Python_UnpackTuple(args, "plsfont", 3, 3, swig_obj)) SWIG_fail;
11981 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11982 if (!SWIG_IsOK(ecode1)) {
11983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
11984 }
11985 arg1 = (PLINT)(val1);
11986 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11987 if (!SWIG_IsOK(ecode2)) {
11988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
11989 }
11990 arg2 = (PLINT)(val2);
11991 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11992 if (!SWIG_IsOK(ecode3)) {
11993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
11994 }
11995 arg3 = (PLINT)(val3);
11996 plsfont(arg1,arg2,arg3);
11997 resultobj = SWIG_Py_Void();
11998 return resultobj;
11999fail:
12000 return NULL;
12001}
12002
12003
12004SWIGINTERN PyObject *_wrap_plshades(PyObject *self, PyObject *args) {
12005 PyObject *resultobj = 0;
12006 PLFLT **arg1 = (PLFLT **) 0 ;
12007 PLINT arg2 ;
12008 PLINT arg3 ;
12009 defined_func arg4 = (defined_func) 0 ;
12010 PLFLT arg5 ;
12011 PLFLT arg6 ;
12012 PLFLT arg7 ;
12013 PLFLT arg8 ;
12014 PLFLT *arg9 = (PLFLT *) 0 ;
12015 PLINT arg10 ;
12016 PLFLT arg11 ;
12017 PLINT arg12 ;
12018 PLFLT arg13 ;
12019 fill_func arg14 = (fill_func) 0 ;
12020 PLBOOL arg15 ;
12021 pltr_func arg16 = (pltr_func) 0 ;
12022 PLPointer arg17 = (PLPointer) 0 ;
12023 PyArrayObject *tmp1 = NULL ;
12024 double val5 ;
12025 int ecode5 = 0 ;
12026 double val6 ;
12027 int ecode6 = 0 ;
12028 double val7 ;
12029 int ecode7 = 0 ;
12030 double val8 ;
12031 int ecode8 = 0 ;
12032 PyArrayObject *tmp9 = NULL ;
12033 double val11 ;
12034 int ecode11 = 0 ;
12035 int val12 ;
12036 int ecode12 = 0 ;
12037 double val13 ;
12038 int ecode13 = 0 ;
12039 int val15 ;
12040 int ecode15 = 0 ;
12041 PyObject *swig_obj[12] ;
12042
12043 {
12044 python_pltr = 0;
12045 arg16 = NULL;
12046 }
12047 {
12048 arg17 = NULL;
12049 }
12050 {
12051 arg4 = NULL;
12052 }
12053 {
12054 arg14 = plfill;
12055 }
12056 (void)self;
12057 if (!SWIG_Python_UnpackTuple(args, "plshades", 10, 12, swig_obj)) SWIG_fail;
12058 {
12059 int i, size;
12060 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12061 if ( tmp1 == NULL )
12062 return NULL;
12063 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12064 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12065 size = arg3;
12066 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12067 for ( i = 0; i < arg2; i++ )
12068 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12069 }
12070 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12071 if (!SWIG_IsOK(ecode5)) {
12072 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
12073 }
12074 arg5 = (PLFLT)(val5);
12075 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12076 if (!SWIG_IsOK(ecode6)) {
12077 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
12078 }
12079 arg6 = (PLFLT)(val6);
12080 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12081 if (!SWIG_IsOK(ecode7)) {
12082 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
12083 }
12084 arg7 = (PLFLT)(val7);
12085 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12086 if (!SWIG_IsOK(ecode8)) {
12087 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
12088 }
12089 arg8 = (PLFLT)(val8);
12090 {
12091 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
12092 if ( tmp9 == NULL )
12093 return NULL;
12094 arg10 = PyArray_DIMS( tmp9 )[0];
12095 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
12096 }
12097 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
12098 if (!SWIG_IsOK(ecode11)) {
12099 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
12100 }
12101 arg11 = (PLFLT)(val11);
12102 ecode12 = SWIG_AsVal_int(swig_obj[7], &val12);
12103 if (!SWIG_IsOK(ecode12)) {
12104 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
12105 }
12106 arg12 = (PLINT)(val12);
12107 ecode13 = SWIG_AsVal_double(swig_obj[8], &val13);
12108 if (!SWIG_IsOK(ecode13)) {
12109 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
12110 }
12111 arg13 = (PLFLT)(val13);
12112 ecode15 = SWIG_AsVal_int(swig_obj[9], &val15);
12113 if (!SWIG_IsOK(ecode15)) {
12114 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
12115 }
12116 arg15 = (PLBOOL)(val15);
12117 if (swig_obj[10]) {
12118 {
12119 // it must be a callable or None
12120 if ( swig_obj[10] == Py_None )
12121 {
12122 arg16 = NULL;
12123 }
12124 else
12125 {
12126 if ( !PyCallable_Check( (PyObject *) swig_obj[10] ) )
12127 {
12128 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12129 return NULL;
12130 }
12131 arg16 = marshal_pltr( swig_obj[10] );
12132 }
12133 }
12134 }
12135 if (swig_obj[11]) {
12136 {
12137 if ( swig_obj[11] == Py_None )
12138 arg17 = NULL;
12139 else
12140 {
12141 arg17 = marshal_PLPointer( swig_obj[11], 0 );
12142 }
12143 }
12144 }
12145 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
12146 resultobj = SWIG_Py_Void();
12147 {
12148 Py_CLEAR( tmp1 );
12149 free( arg1 );
12150 }
12151 {
12152 Py_CLEAR( tmp9 );
12153 }
12154 {
12155 cleanup_pltr();
12156 }
12157 {
12159 }
12160 return resultobj;
12161fail:
12162 {
12163 Py_CLEAR( tmp1 );
12164 free( arg1 );
12165 }
12166 {
12167 Py_CLEAR( tmp9 );
12168 }
12169 {
12170 cleanup_pltr();
12171 }
12172 {
12174 }
12175 return NULL;
12176}
12177
12178
12179SWIGINTERN PyObject *_wrap_plshade(PyObject *self, PyObject *args) {
12180 PyObject *resultobj = 0;
12181 PLFLT **arg1 = (PLFLT **) 0 ;
12182 PLINT arg2 ;
12183 PLINT arg3 ;
12184 defined_func arg4 = (defined_func) 0 ;
12185 PLFLT arg5 ;
12186 PLFLT arg6 ;
12187 PLFLT arg7 ;
12188 PLFLT arg8 ;
12189 PLFLT arg9 ;
12190 PLFLT arg10 ;
12191 PLINT arg11 ;
12192 PLFLT arg12 ;
12193 PLFLT arg13 ;
12194 PLINT arg14 ;
12195 PLFLT arg15 ;
12196 PLINT arg16 ;
12197 PLFLT arg17 ;
12198 fill_func arg18 = (fill_func) 0 ;
12199 PLBOOL arg19 ;
12200 pltr_func arg20 = (pltr_func) 0 ;
12201 PLPointer arg21 = (PLPointer) 0 ;
12202 PyArrayObject *tmp1 = NULL ;
12203 double val5 ;
12204 int ecode5 = 0 ;
12205 double val6 ;
12206 int ecode6 = 0 ;
12207 double val7 ;
12208 int ecode7 = 0 ;
12209 double val8 ;
12210 int ecode8 = 0 ;
12211 double val9 ;
12212 int ecode9 = 0 ;
12213 double val10 ;
12214 int ecode10 = 0 ;
12215 int val11 ;
12216 int ecode11 = 0 ;
12217 double val12 ;
12218 int ecode12 = 0 ;
12219 double val13 ;
12220 int ecode13 = 0 ;
12221 int val14 ;
12222 int ecode14 = 0 ;
12223 double val15 ;
12224 int ecode15 = 0 ;
12225 int val16 ;
12226 int ecode16 = 0 ;
12227 double val17 ;
12228 int ecode17 = 0 ;
12229 int val19 ;
12230 int ecode19 = 0 ;
12231 PyObject *swig_obj[17] ;
12232
12233 {
12234 python_pltr = 0;
12235 arg20 = NULL;
12236 }
12237 {
12238 arg21 = NULL;
12239 }
12240 {
12241 arg4 = NULL;
12242 }
12243 {
12244 arg18 = plfill;
12245 }
12246 (void)self;
12247 if (!SWIG_Python_UnpackTuple(args, "plshade", 15, 17, swig_obj)) SWIG_fail;
12248 {
12249 int i, size;
12250 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12251 if ( tmp1 == NULL )
12252 return NULL;
12253 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12254 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12255 size = arg3;
12256 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12257 for ( i = 0; i < arg2; i++ )
12258 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12259 }
12260 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12261 if (!SWIG_IsOK(ecode5)) {
12262 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12263 }
12264 arg5 = (PLFLT)(val5);
12265 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12266 if (!SWIG_IsOK(ecode6)) {
12267 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12268 }
12269 arg6 = (PLFLT)(val6);
12270 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12271 if (!SWIG_IsOK(ecode7)) {
12272 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12273 }
12274 arg7 = (PLFLT)(val7);
12275 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12276 if (!SWIG_IsOK(ecode8)) {
12277 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12278 }
12279 arg8 = (PLFLT)(val8);
12280 ecode9 = SWIG_AsVal_double(swig_obj[5], &val9);
12281 if (!SWIG_IsOK(ecode9)) {
12282 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12283 }
12284 arg9 = (PLFLT)(val9);
12285 ecode10 = SWIG_AsVal_double(swig_obj[6], &val10);
12286 if (!SWIG_IsOK(ecode10)) {
12287 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12288 }
12289 arg10 = (PLFLT)(val10);
12290 ecode11 = SWIG_AsVal_int(swig_obj[7], &val11);
12291 if (!SWIG_IsOK(ecode11)) {
12292 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12293 }
12294 arg11 = (PLINT)(val11);
12295 ecode12 = SWIG_AsVal_double(swig_obj[8], &val12);
12296 if (!SWIG_IsOK(ecode12)) {
12297 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12298 }
12299 arg12 = (PLFLT)(val12);
12300 ecode13 = SWIG_AsVal_double(swig_obj[9], &val13);
12301 if (!SWIG_IsOK(ecode13)) {
12302 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12303 }
12304 arg13 = (PLFLT)(val13);
12305 ecode14 = SWIG_AsVal_int(swig_obj[10], &val14);
12306 if (!SWIG_IsOK(ecode14)) {
12307 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12308 }
12309 arg14 = (PLINT)(val14);
12310 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
12311 if (!SWIG_IsOK(ecode15)) {
12312 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12313 }
12314 arg15 = (PLFLT)(val15);
12315 ecode16 = SWIG_AsVal_int(swig_obj[12], &val16);
12316 if (!SWIG_IsOK(ecode16)) {
12317 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12318 }
12319 arg16 = (PLINT)(val16);
12320 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
12321 if (!SWIG_IsOK(ecode17)) {
12322 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12323 }
12324 arg17 = (PLFLT)(val17);
12325 ecode19 = SWIG_AsVal_int(swig_obj[14], &val19);
12326 if (!SWIG_IsOK(ecode19)) {
12327 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12328 }
12329 arg19 = (PLBOOL)(val19);
12330 if (swig_obj[15]) {
12331 {
12332 // it must be a callable or None
12333 if ( swig_obj[15] == Py_None )
12334 {
12335 arg20 = NULL;
12336 }
12337 else
12338 {
12339 if ( !PyCallable_Check( (PyObject *) swig_obj[15] ) )
12340 {
12341 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12342 return NULL;
12343 }
12344 arg20 = marshal_pltr( swig_obj[15] );
12345 }
12346 }
12347 }
12348 if (swig_obj[16]) {
12349 {
12350 if ( swig_obj[16] == Py_None )
12351 arg21 = NULL;
12352 else
12353 {
12354 arg21 = marshal_PLPointer( swig_obj[16], 0 );
12355 }
12356 }
12357 }
12358 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12359 resultobj = SWIG_Py_Void();
12360 {
12361 Py_CLEAR( tmp1 );
12362 free( arg1 );
12363 }
12364 {
12365 cleanup_pltr();
12366 }
12367 {
12369 }
12370 return resultobj;
12371fail:
12372 {
12373 Py_CLEAR( tmp1 );
12374 free( arg1 );
12375 }
12376 {
12377 cleanup_pltr();
12378 }
12379 {
12381 }
12382 return NULL;
12383}
12384
12385
12386SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *self, PyObject *args) {
12387 PyObject *resultobj = 0;
12388 label_func arg1 = (label_func) 0 ;
12389 PLPointer arg2 = (PLPointer) 0 ;
12390 int res2 ;
12391 PyObject *swig_obj[2] ;
12392
12393 (void)self;
12394 if (!SWIG_Python_UnpackTuple(args, "plslabelfunc", 2, 2, swig_obj)) SWIG_fail;
12395 {
12396 // Release reference to previous function if applicable
12397 if ( python_label )
12398 {
12399 Py_CLEAR( python_label );
12400 python_label = 0;
12401 }
12402 // it must be a callable or None
12403 if ( swig_obj[0] == Py_None )
12404 {
12405 arg1 = NULL;
12406 }
12407 else
12408 {
12409 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12410 {
12411 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12412 return NULL;
12413 }
12414 // hold a reference to it
12415 Py_XINCREF( (PyObject *) swig_obj[0] );
12416 python_label = (PyObject *) swig_obj[0];
12417 // this function handles calling the python function
12418 arg1 = do_label_callback;
12419 }
12420 }
12421 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12422 if (!SWIG_IsOK(res2)) {
12423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12424 }
12425 plslabelfunc(arg1,arg2);
12426 resultobj = SWIG_Py_Void();
12427 return resultobj;
12428fail:
12429 return NULL;
12430}
12431
12432
12433SWIGINTERN PyObject *_wrap_plsmaj(PyObject *self, PyObject *args) {
12434 PyObject *resultobj = 0;
12435 PLFLT arg1 ;
12436 PLFLT arg2 ;
12437 double val1 ;
12438 int ecode1 = 0 ;
12439 double val2 ;
12440 int ecode2 = 0 ;
12441 PyObject *swig_obj[2] ;
12442
12443 (void)self;
12444 if (!SWIG_Python_UnpackTuple(args, "plsmaj", 2, 2, swig_obj)) SWIG_fail;
12445 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12446 if (!SWIG_IsOK(ecode1)) {
12447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12448 }
12449 arg1 = (PLFLT)(val1);
12450 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12451 if (!SWIG_IsOK(ecode2)) {
12452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12453 }
12454 arg2 = (PLFLT)(val2);
12455 plsmaj(arg1,arg2);
12456 resultobj = SWIG_Py_Void();
12457 return resultobj;
12458fail:
12459 return NULL;
12460}
12461
12462
12463SWIGINTERN PyObject *_wrap_plsmem(PyObject *self, PyObject *args) {
12464 PyObject *resultobj = 0;
12465 PLINT arg1 ;
12466 PLINT arg2 ;
12467 void *arg3 = (void *) 0 ;
12468 int val1 ;
12469 int ecode1 = 0 ;
12470 int val2 ;
12471 int ecode2 = 0 ;
12472 PyObject *swig_obj[3] ;
12473
12474 (void)self;
12475 if (!SWIG_Python_UnpackTuple(args, "plsmem", 3, 3, swig_obj)) SWIG_fail;
12476 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12477 if (!SWIG_IsOK(ecode1)) {
12478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12479 }
12480 arg1 = (PLINT)(val1);
12481 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12482 if (!SWIG_IsOK(ecode2)) {
12483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12484 }
12485 arg2 = (PLINT)(val2);
12486 {
12487 int res; void *buf = 0;
12488#ifndef Py_LIMITED_API
12489 Py_buffer view;
12490 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12491#else
12492#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12493#pragma GCC diagnostic push
12494#pragma GCC diagnostic ignored "-Wdeprecated"
12495#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12496#elif defined(_MSC_VER)
12497#pragma warning(push)
12498#pragma warning(disable: 4996)
12499#endif
12500 Py_ssize_t size;
12501 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12502#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12503#pragma GCC diagnostic pop
12504#elif defined(_MSC_VER)
12505#pragma warning(pop)
12506#endif
12507#endif
12508 if (res < 0) {
12509 PyErr_Clear();
12510 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem)""'");
12511 }
12512#ifndef Py_LIMITED_API
12513 buf = view.buf;
12514 PyBuffer_Release(&view);
12515#endif
12516 arg3 = (void *) buf;
12517 }
12518 plsmem(arg1,arg2,arg3);
12519 resultobj = SWIG_Py_Void();
12520 return resultobj;
12521fail:
12522 return NULL;
12523}
12524
12525
12526SWIGINTERN PyObject *_wrap_plsmema(PyObject *self, PyObject *args) {
12527 PyObject *resultobj = 0;
12528 PLINT arg1 ;
12529 PLINT arg2 ;
12530 void *arg3 = (void *) 0 ;
12531 int val1 ;
12532 int ecode1 = 0 ;
12533 int val2 ;
12534 int ecode2 = 0 ;
12535 PyObject *swig_obj[3] ;
12536
12537 (void)self;
12538 if (!SWIG_Python_UnpackTuple(args, "plsmema", 3, 3, swig_obj)) SWIG_fail;
12539 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12540 if (!SWIG_IsOK(ecode1)) {
12541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12542 }
12543 arg1 = (PLINT)(val1);
12544 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12545 if (!SWIG_IsOK(ecode2)) {
12546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12547 }
12548 arg2 = (PLINT)(val2);
12549 {
12550 int res; void *buf = 0;
12551#ifndef Py_LIMITED_API
12552 Py_buffer view;
12553 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12554#else
12555#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12556#pragma GCC diagnostic push
12557#pragma GCC diagnostic ignored "-Wdeprecated"
12558#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12559#elif defined(_MSC_VER)
12560#pragma warning(push)
12561#pragma warning(disable: 4996)
12562#endif
12563 Py_ssize_t size;
12564 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12565#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12566#pragma GCC diagnostic pop
12567#elif defined(_MSC_VER)
12568#pragma warning(pop)
12569#endif
12570#endif
12571 if (res < 0) {
12572 PyErr_Clear();
12573 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem)""'");
12574 }
12575#ifndef Py_LIMITED_API
12576 buf = view.buf;
12577 PyBuffer_Release(&view);
12578#endif
12579 arg3 = (void *) buf;
12580 }
12581 plsmema(arg1,arg2,arg3);
12582 resultobj = SWIG_Py_Void();
12583 return resultobj;
12584fail:
12585 return NULL;
12586}
12587
12588
12589SWIGINTERN PyObject *_wrap_plsmin(PyObject *self, PyObject *args) {
12590 PyObject *resultobj = 0;
12591 PLFLT arg1 ;
12592 PLFLT arg2 ;
12593 double val1 ;
12594 int ecode1 = 0 ;
12595 double val2 ;
12596 int ecode2 = 0 ;
12597 PyObject *swig_obj[2] ;
12598
12599 (void)self;
12600 if (!SWIG_Python_UnpackTuple(args, "plsmin", 2, 2, swig_obj)) SWIG_fail;
12601 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12602 if (!SWIG_IsOK(ecode1)) {
12603 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12604 }
12605 arg1 = (PLFLT)(val1);
12606 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12607 if (!SWIG_IsOK(ecode2)) {
12608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12609 }
12610 arg2 = (PLFLT)(val2);
12611 plsmin(arg1,arg2);
12612 resultobj = SWIG_Py_Void();
12613 return resultobj;
12614fail:
12615 return NULL;
12616}
12617
12618
12619SWIGINTERN PyObject *_wrap_plsori(PyObject *self, PyObject *args) {
12620 PyObject *resultobj = 0;
12621 PLINT arg1 ;
12622 int val1 ;
12623 int ecode1 = 0 ;
12624 PyObject *swig_obj[1] ;
12625
12626 (void)self;
12627 if (!args) SWIG_fail;
12628 swig_obj[0] = args;
12629 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12630 if (!SWIG_IsOK(ecode1)) {
12631 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12632 }
12633 arg1 = (PLINT)(val1);
12634 plsori(arg1);
12635 resultobj = SWIG_Py_Void();
12636 return resultobj;
12637fail:
12638 return NULL;
12639}
12640
12641
12642SWIGINTERN PyObject *_wrap_plspage(PyObject *self, PyObject *args) {
12643 PyObject *resultobj = 0;
12644 PLFLT arg1 ;
12645 PLFLT arg2 ;
12646 PLINT arg3 ;
12647 PLINT arg4 ;
12648 PLINT arg5 ;
12649 PLINT arg6 ;
12650 double val1 ;
12651 int ecode1 = 0 ;
12652 double val2 ;
12653 int ecode2 = 0 ;
12654 int val3 ;
12655 int ecode3 = 0 ;
12656 int val4 ;
12657 int ecode4 = 0 ;
12658 int val5 ;
12659 int ecode5 = 0 ;
12660 int val6 ;
12661 int ecode6 = 0 ;
12662 PyObject *swig_obj[6] ;
12663
12664 (void)self;
12665 if (!SWIG_Python_UnpackTuple(args, "plspage", 6, 6, swig_obj)) SWIG_fail;
12666 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12667 if (!SWIG_IsOK(ecode1)) {
12668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12669 }
12670 arg1 = (PLFLT)(val1);
12671 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12672 if (!SWIG_IsOK(ecode2)) {
12673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12674 }
12675 arg2 = (PLFLT)(val2);
12676 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12677 if (!SWIG_IsOK(ecode3)) {
12678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12679 }
12680 arg3 = (PLINT)(val3);
12681 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
12682 if (!SWIG_IsOK(ecode4)) {
12683 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12684 }
12685 arg4 = (PLINT)(val4);
12686 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
12687 if (!SWIG_IsOK(ecode5)) {
12688 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12689 }
12690 arg5 = (PLINT)(val5);
12691 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
12692 if (!SWIG_IsOK(ecode6)) {
12693 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12694 }
12695 arg6 = (PLINT)(val6);
12696 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12697 resultobj = SWIG_Py_Void();
12698 return resultobj;
12699fail:
12700 return NULL;
12701}
12702
12703
12704SWIGINTERN PyObject *_wrap_plspal0(PyObject *self, PyObject *args) {
12705 PyObject *resultobj = 0;
12706 char *arg1 = (char *) 0 ;
12707 int res1 ;
12708 char *buf1 = 0 ;
12709 int alloc1 = 0 ;
12710 PyObject *swig_obj[1] ;
12711
12712 (void)self;
12713 if (!args) SWIG_fail;
12714 swig_obj[0] = args;
12715 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12716 if (!SWIG_IsOK(res1)) {
12717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12718 }
12719 arg1 = (char *)(buf1);
12720 plspal0((char const *)arg1);
12721 resultobj = SWIG_Py_Void();
12722 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12723 return resultobj;
12724fail:
12725 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12726 return NULL;
12727}
12728
12729
12730SWIGINTERN PyObject *_wrap_plspal1(PyObject *self, PyObject *args) {
12731 PyObject *resultobj = 0;
12732 char *arg1 = (char *) 0 ;
12733 PLBOOL arg2 ;
12734 int res1 ;
12735 char *buf1 = 0 ;
12736 int alloc1 = 0 ;
12737 int val2 ;
12738 int ecode2 = 0 ;
12739 PyObject *swig_obj[2] ;
12740
12741 (void)self;
12742 if (!SWIG_Python_UnpackTuple(args, "plspal1", 2, 2, swig_obj)) SWIG_fail;
12743 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12744 if (!SWIG_IsOK(res1)) {
12745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12746 }
12747 arg1 = (char *)(buf1);
12748 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12749 if (!SWIG_IsOK(ecode2)) {
12750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12751 }
12752 arg2 = (PLBOOL)(val2);
12753 plspal1((char const *)arg1,arg2);
12754 resultobj = SWIG_Py_Void();
12755 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12756 return resultobj;
12757fail:
12758 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12759 return NULL;
12760}
12761
12762
12763SWIGINTERN PyObject *_wrap_plspause(PyObject *self, PyObject *args) {
12764 PyObject *resultobj = 0;
12765 PLBOOL arg1 ;
12766 int val1 ;
12767 int ecode1 = 0 ;
12768 PyObject *swig_obj[1] ;
12769
12770 (void)self;
12771 if (!args) SWIG_fail;
12772 swig_obj[0] = args;
12773 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12774 if (!SWIG_IsOK(ecode1)) {
12775 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12776 }
12777 arg1 = (PLBOOL)(val1);
12778 plspause(arg1);
12779 resultobj = SWIG_Py_Void();
12780 return resultobj;
12781fail:
12782 return NULL;
12783}
12784
12785
12786SWIGINTERN PyObject *_wrap_plsstrm(PyObject *self, PyObject *args) {
12787 PyObject *resultobj = 0;
12788 PLINT arg1 ;
12789 int val1 ;
12790 int ecode1 = 0 ;
12791 PyObject *swig_obj[1] ;
12792
12793 (void)self;
12794 if (!args) SWIG_fail;
12795 swig_obj[0] = args;
12796 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12797 if (!SWIG_IsOK(ecode1)) {
12798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12799 }
12800 arg1 = (PLINT)(val1);
12801 plsstrm(arg1);
12802 resultobj = SWIG_Py_Void();
12803 return resultobj;
12804fail:
12805 return NULL;
12806}
12807
12808
12809SWIGINTERN PyObject *_wrap_plssub(PyObject *self, PyObject *args) {
12810 PyObject *resultobj = 0;
12811 PLINT arg1 ;
12812 PLINT arg2 ;
12813 int val1 ;
12814 int ecode1 = 0 ;
12815 int val2 ;
12816 int ecode2 = 0 ;
12817 PyObject *swig_obj[2] ;
12818
12819 (void)self;
12820 if (!SWIG_Python_UnpackTuple(args, "plssub", 2, 2, swig_obj)) SWIG_fail;
12821 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12822 if (!SWIG_IsOK(ecode1)) {
12823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12824 }
12825 arg1 = (PLINT)(val1);
12826 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12827 if (!SWIG_IsOK(ecode2)) {
12828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12829 }
12830 arg2 = (PLINT)(val2);
12831 plssub(arg1,arg2);
12832 resultobj = SWIG_Py_Void();
12833 return resultobj;
12834fail:
12835 return NULL;
12836}
12837
12838
12839SWIGINTERN PyObject *_wrap_plssym(PyObject *self, PyObject *args) {
12840 PyObject *resultobj = 0;
12841 PLFLT arg1 ;
12842 PLFLT arg2 ;
12843 double val1 ;
12844 int ecode1 = 0 ;
12845 double val2 ;
12846 int ecode2 = 0 ;
12847 PyObject *swig_obj[2] ;
12848
12849 (void)self;
12850 if (!SWIG_Python_UnpackTuple(args, "plssym", 2, 2, swig_obj)) SWIG_fail;
12851 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12852 if (!SWIG_IsOK(ecode1)) {
12853 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12854 }
12855 arg1 = (PLFLT)(val1);
12856 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12857 if (!SWIG_IsOK(ecode2)) {
12858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12859 }
12860 arg2 = (PLFLT)(val2);
12861 plssym(arg1,arg2);
12862 resultobj = SWIG_Py_Void();
12863 return resultobj;
12864fail:
12865 return NULL;
12866}
12867
12868
12869SWIGINTERN PyObject *_wrap_plstar(PyObject *self, PyObject *args) {
12870 PyObject *resultobj = 0;
12871 PLINT arg1 ;
12872 PLINT arg2 ;
12873 int val1 ;
12874 int ecode1 = 0 ;
12875 int val2 ;
12876 int ecode2 = 0 ;
12877 PyObject *swig_obj[2] ;
12878
12879 (void)self;
12880 if (!SWIG_Python_UnpackTuple(args, "plstar", 2, 2, swig_obj)) SWIG_fail;
12881 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12882 if (!SWIG_IsOK(ecode1)) {
12883 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12884 }
12885 arg1 = (PLINT)(val1);
12886 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12887 if (!SWIG_IsOK(ecode2)) {
12888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12889 }
12890 arg2 = (PLINT)(val2);
12891 plstar(arg1,arg2);
12892 resultobj = SWIG_Py_Void();
12893 return resultobj;
12894fail:
12895 return NULL;
12896}
12897
12898
12899SWIGINTERN PyObject *_wrap_plstart(PyObject *self, PyObject *args) {
12900 PyObject *resultobj = 0;
12901 char *arg1 = (char *) 0 ;
12902 PLINT arg2 ;
12903 PLINT arg3 ;
12904 int res1 ;
12905 char *buf1 = 0 ;
12906 int alloc1 = 0 ;
12907 int val2 ;
12908 int ecode2 = 0 ;
12909 int val3 ;
12910 int ecode3 = 0 ;
12911 PyObject *swig_obj[3] ;
12912
12913 (void)self;
12914 if (!SWIG_Python_UnpackTuple(args, "plstart", 3, 3, swig_obj)) SWIG_fail;
12915 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12916 if (!SWIG_IsOK(res1)) {
12917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12918 }
12919 arg1 = (char *)(buf1);
12920 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12921 if (!SWIG_IsOK(ecode2)) {
12922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12923 }
12924 arg2 = (PLINT)(val2);
12925 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12926 if (!SWIG_IsOK(ecode3)) {
12927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12928 }
12929 arg3 = (PLINT)(val3);
12930 plstart((char const *)arg1,arg2,arg3);
12931 resultobj = SWIG_Py_Void();
12932 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12933 return resultobj;
12934fail:
12935 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12936 return NULL;
12937}
12938
12939
12940SWIGINTERN PyObject *_wrap_plstransform(PyObject *self, PyObject *args) {
12941 PyObject *resultobj = 0;
12942 ct_func arg1 = (ct_func) 0 ;
12943 PLPointer arg2 = (PLPointer) 0 ;
12944 int res2 ;
12945 PyObject *swig_obj[2] ;
12946
12947 {
12948 python_ct = 0;
12949 arg1 = NULL;
12950 }
12951 (void)self;
12952 if (!SWIG_Python_UnpackTuple(args, "plstransform", 0, 2, swig_obj)) SWIG_fail;
12953 if (swig_obj[0]) {
12954 {
12955 if ( python_ct )
12956 cleanup_ct();
12957 // it must be a callable or none
12958 if ( swig_obj[0] == Py_None )
12959 {
12960 arg1 = NULL;
12961 }
12962 else
12963 {
12964 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12965 {
12966 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
12967 return NULL;
12968 }
12969 arg1 = marshal_ct( swig_obj[0] );
12970 }
12971 }
12972 }
12973 if (swig_obj[1]) {
12974 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12975 if (!SWIG_IsOK(res2)) {
12976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
12977 }
12978 }
12979 plstransform(arg1,arg2);
12980 resultobj = SWIG_Py_Void();
12981 return resultobj;
12982fail:
12983 return NULL;
12984}
12985
12986
12987SWIGINTERN PyObject *_wrap_plstring(PyObject *self, PyObject *args) {
12988 PyObject *resultobj = 0;
12989 PLINT arg1 ;
12990 PLFLT *arg2 = (PLFLT *) 0 ;
12991 PLFLT *arg3 = (PLFLT *) 0 ;
12992 char *arg4 = (char *) 0 ;
12993 PyArrayObject *tmp1 = NULL ;
12994 PyArrayObject *tmp3 = NULL ;
12995 int res4 ;
12996 char *buf4 = 0 ;
12997 int alloc4 = 0 ;
12998 PyObject *swig_obj[3] ;
12999
13000 (void)self;
13001 if (!SWIG_Python_UnpackTuple(args, "plstring", 3, 3, swig_obj)) SWIG_fail;
13002 {
13003 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13004 if ( tmp1 == NULL )
13005 return NULL;
13006 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13007 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13008 }
13009 {
13010 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13011 if ( tmp3 == NULL )
13012 return NULL;
13013 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13014 {
13015 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13016 return NULL;
13017 }
13018 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13019 }
13020 res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
13021 if (!SWIG_IsOK(res4)) {
13022 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
13023 }
13024 arg4 = (char *)(buf4);
13025 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
13026 resultobj = SWIG_Py_Void();
13027 {
13028 Py_CLEAR( tmp1 );
13029 }
13030 {
13031 Py_CLEAR( tmp3 );
13032 }
13033 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13034 return resultobj;
13035fail:
13036 {
13037 Py_CLEAR( tmp1 );
13038 }
13039 {
13040 Py_CLEAR( tmp3 );
13041 }
13042 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13043 return NULL;
13044}
13045
13046
13047SWIGINTERN PyObject *_wrap_plstring3(PyObject *self, PyObject *args) {
13048 PyObject *resultobj = 0;
13049 PLINT arg1 ;
13050 PLFLT *arg2 = (PLFLT *) 0 ;
13051 PLFLT *arg3 = (PLFLT *) 0 ;
13052 PLFLT *arg4 = (PLFLT *) 0 ;
13053 char *arg5 = (char *) 0 ;
13054 PyArrayObject *tmp1 = NULL ;
13055 PyArrayObject *tmp3 = NULL ;
13056 PyArrayObject *tmp4 = NULL ;
13057 int res5 ;
13058 char *buf5 = 0 ;
13059 int alloc5 = 0 ;
13060 PyObject *swig_obj[4] ;
13061
13062 (void)self;
13063 if (!SWIG_Python_UnpackTuple(args, "plstring3", 4, 4, swig_obj)) SWIG_fail;
13064 {
13065 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13066 if ( tmp1 == NULL )
13067 return NULL;
13068 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13069 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13070 }
13071 {
13072 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13073 if ( tmp3 == NULL )
13074 return NULL;
13075 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13076 {
13077 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13078 return NULL;
13079 }
13080 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13081 }
13082 {
13083 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
13084 if ( tmp4 == NULL )
13085 return NULL;
13086 if ( PyArray_DIMS( tmp4 )[0] != Alen )
13087 {
13088 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13089 return NULL;
13090 }
13091 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
13092 }
13093 res5 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf5, NULL, &alloc5);
13094 if (!SWIG_IsOK(res5)) {
13095 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
13096 }
13097 arg5 = (char *)(buf5);
13098 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
13099 resultobj = SWIG_Py_Void();
13100 {
13101 Py_CLEAR( tmp1 );
13102 }
13103 {
13104 Py_CLEAR( tmp3 );
13105 }
13106 {
13107 Py_CLEAR( tmp4 );
13108 }
13109 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13110 return resultobj;
13111fail:
13112 {
13113 Py_CLEAR( tmp1 );
13114 }
13115 {
13116 Py_CLEAR( tmp3 );
13117 }
13118 {
13119 Py_CLEAR( tmp4 );
13120 }
13121 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13122 return NULL;
13123}
13124
13125
13126SWIGINTERN PyObject *_wrap_plstripa(PyObject *self, PyObject *args) {
13127 PyObject *resultobj = 0;
13128 PLINT arg1 ;
13129 PLINT arg2 ;
13130 PLFLT arg3 ;
13131 PLFLT arg4 ;
13132 int val1 ;
13133 int ecode1 = 0 ;
13134 int val2 ;
13135 int ecode2 = 0 ;
13136 double val3 ;
13137 int ecode3 = 0 ;
13138 double val4 ;
13139 int ecode4 = 0 ;
13140 PyObject *swig_obj[4] ;
13141
13142 (void)self;
13143 if (!SWIG_Python_UnpackTuple(args, "plstripa", 4, 4, swig_obj)) SWIG_fail;
13144 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13145 if (!SWIG_IsOK(ecode1)) {
13146 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
13147 }
13148 arg1 = (PLINT)(val1);
13149 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13150 if (!SWIG_IsOK(ecode2)) {
13151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
13152 }
13153 arg2 = (PLINT)(val2);
13154 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13155 if (!SWIG_IsOK(ecode3)) {
13156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
13157 }
13158 arg3 = (PLFLT)(val3);
13159 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13160 if (!SWIG_IsOK(ecode4)) {
13161 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
13162 }
13163 arg4 = (PLFLT)(val4);
13164 plstripa(arg1,arg2,arg3,arg4);
13165 resultobj = SWIG_Py_Void();
13166 return resultobj;
13167fail:
13168 return NULL;
13169}
13170
13171
13172SWIGINTERN PyObject *_wrap_plstripc(PyObject *self, PyObject *args) {
13173 PyObject *resultobj = 0;
13174 PLINT *arg1 = (PLINT *) 0 ;
13175 char *arg2 = (char *) 0 ;
13176 char *arg3 = (char *) 0 ;
13177 PLFLT arg4 ;
13178 PLFLT arg5 ;
13179 PLFLT arg6 ;
13180 PLFLT arg7 ;
13181 PLFLT arg8 ;
13182 PLFLT arg9 ;
13183 PLFLT arg10 ;
13184 PLBOOL arg11 ;
13185 PLBOOL arg12 ;
13186 PLINT arg13 ;
13187 PLINT arg14 ;
13188 PLINT *arg15 = (PLINT *) 0 ;
13189 PLINT *arg16 = (PLINT *) 0 ;
13190 char **arg17 = (char **) (char **)0 ;
13191 char *arg18 = (char *) 0 ;
13192 char *arg19 = (char *) 0 ;
13193 char *arg20 = (char *) 0 ;
13194 PLINT temp1 ;
13195 int res1 = SWIG_TMPOBJ ;
13196 int res2 ;
13197 char *buf2 = 0 ;
13198 int alloc2 = 0 ;
13199 int res3 ;
13200 char *buf3 = 0 ;
13201 int alloc3 = 0 ;
13202 double val4 ;
13203 int ecode4 = 0 ;
13204 double val5 ;
13205 int ecode5 = 0 ;
13206 double val6 ;
13207 int ecode6 = 0 ;
13208 double val7 ;
13209 int ecode7 = 0 ;
13210 double val8 ;
13211 int ecode8 = 0 ;
13212 double val9 ;
13213 int ecode9 = 0 ;
13214 double val10 ;
13215 int ecode10 = 0 ;
13216 int val11 ;
13217 int ecode11 = 0 ;
13218 int val12 ;
13219 int ecode12 = 0 ;
13220 int val13 ;
13221 int ecode13 = 0 ;
13222 int val14 ;
13223 int ecode14 = 0 ;
13224 PyArrayObject *tmp15 = NULL ;
13225 PyArrayObject *tmp16 = NULL ;
13226 char **tmp17 = NULL ;
13227 int res18 ;
13228 char *buf18 = 0 ;
13229 int alloc18 = 0 ;
13230 int res19 ;
13231 char *buf19 = 0 ;
13232 int alloc19 = 0 ;
13233 int res20 ;
13234 char *buf20 = 0 ;
13235 int alloc20 = 0 ;
13236 PyObject *swig_obj[19] ;
13237
13238 arg1 = &temp1;
13239 (void)self;
13240 if (!SWIG_Python_UnpackTuple(args, "plstripc", 19, 19, swig_obj)) SWIG_fail;
13241 res2 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf2, NULL, &alloc2);
13242 if (!SWIG_IsOK(res2)) {
13243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13244 }
13245 arg2 = (char *)(buf2);
13246 res3 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf3, NULL, &alloc3);
13247 if (!SWIG_IsOK(res3)) {
13248 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13249 }
13250 arg3 = (char *)(buf3);
13251 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
13252 if (!SWIG_IsOK(ecode4)) {
13253 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13254 }
13255 arg4 = (PLFLT)(val4);
13256 ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
13257 if (!SWIG_IsOK(ecode5)) {
13258 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13259 }
13260 arg5 = (PLFLT)(val5);
13261 ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
13262 if (!SWIG_IsOK(ecode6)) {
13263 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13264 }
13265 arg6 = (PLFLT)(val6);
13266 ecode7 = SWIG_AsVal_double(swig_obj[5], &val7);
13267 if (!SWIG_IsOK(ecode7)) {
13268 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13269 }
13270 arg7 = (PLFLT)(val7);
13271 ecode8 = SWIG_AsVal_double(swig_obj[6], &val8);
13272 if (!SWIG_IsOK(ecode8)) {
13273 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13274 }
13275 arg8 = (PLFLT)(val8);
13276 ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
13277 if (!SWIG_IsOK(ecode9)) {
13278 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13279 }
13280 arg9 = (PLFLT)(val9);
13281 ecode10 = SWIG_AsVal_double(swig_obj[8], &val10);
13282 if (!SWIG_IsOK(ecode10)) {
13283 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13284 }
13285 arg10 = (PLFLT)(val10);
13286 ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
13287 if (!SWIG_IsOK(ecode11)) {
13288 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13289 }
13290 arg11 = (PLBOOL)(val11);
13291 ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
13292 if (!SWIG_IsOK(ecode12)) {
13293 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13294 }
13295 arg12 = (PLBOOL)(val12);
13296 ecode13 = SWIG_AsVal_int(swig_obj[11], &val13);
13297 if (!SWIG_IsOK(ecode13)) {
13298 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13299 }
13300 arg13 = (PLINT)(val13);
13301 ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
13302 if (!SWIG_IsOK(ecode14)) {
13303 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13304 }
13305 arg14 = (PLINT)(val14);
13306 {
13307 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
13308 if ( tmp15 == NULL )
13309 return NULL;
13310 Alen = PyArray_DIMS( tmp15 )[0];
13311 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13312 }
13313 {
13314 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[14], NPY_PLINT, 1, 1 );
13315 if ( tmp16 == NULL )
13316 return NULL;
13317 if ( PyArray_DIMS( tmp16 )[0] != Alen )
13318 {
13319 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13320 return NULL;
13321 }
13322 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13323 }
13324 {
13325 int i;
13326 PyObject *elt, *unicode_string;
13327
13328 if ( !PySequence_Check( swig_obj[15] ) || PySequence_Size( swig_obj[15] ) != 4 )
13329 {
13330 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13331 return NULL;
13332 }
13333 if ( Alen != 4 )
13334 {
13335 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13336 return NULL;
13337 }
13338 tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13339 if ( tmp17 == NULL )
13340 return NULL;
13341 arg17 = tmp17;
13342 for ( i = 0; i < 4; i++ )
13343 {
13344 arg17[i] = NULL;
13345 elt = PySequence_Fast_GET_ITEM( swig_obj[15], i );
13346 if ( PyString_Check( elt ) )
13347 {
13348 arg17[i] = PyString_AsString( elt );
13349 }
13350 else if ( PyUnicode_Check( elt ) )
13351 {
13352 unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
13353 arg17[i] = PyBytes_AS_STRING( unicode_string );
13354 }
13355 if ( arg17[i] == NULL )
13356 {
13357 free( tmp17 );
13358 return NULL;
13359 }
13360 }
13361 }
13362 res18 = SWIG_AsCharPtrAndSize(swig_obj[16], &buf18, NULL, &alloc18);
13363 if (!SWIG_IsOK(res18)) {
13364 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13365 }
13366 arg18 = (char *)(buf18);
13367 res19 = SWIG_AsCharPtrAndSize(swig_obj[17], &buf19, NULL, &alloc19);
13368 if (!SWIG_IsOK(res19)) {
13369 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13370 }
13371 arg19 = (char *)(buf19);
13372 res20 = SWIG_AsCharPtrAndSize(swig_obj[18], &buf20, NULL, &alloc20);
13373 if (!SWIG_IsOK(res20)) {
13374 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13375 }
13376 arg20 = (char *)(buf20);
13377 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);
13378 resultobj = SWIG_Py_Void();
13379 if (SWIG_IsTmpObj(res1)) {
13380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
13381 } else {
13382 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13384 }
13385 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13386 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13387 {
13388 Py_CLEAR( tmp15 );
13389 }
13390 {
13391 Py_CLEAR( tmp16 );
13392 }
13393 {
13394 free( tmp17 );
13395 }
13396 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13397 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13398 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13399 return resultobj;
13400fail:
13401 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13402 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13403 {
13404 Py_CLEAR( tmp15 );
13405 }
13406 {
13407 Py_CLEAR( tmp16 );
13408 }
13409 {
13410 free( tmp17 );
13411 }
13412 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13413 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13414 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13415 return NULL;
13416}
13417
13418
13419SWIGINTERN PyObject *_wrap_plstripd(PyObject *self, PyObject *args) {
13420 PyObject *resultobj = 0;
13421 PLINT arg1 ;
13422 int val1 ;
13423 int ecode1 = 0 ;
13424 PyObject *swig_obj[1] ;
13425
13426 (void)self;
13427 if (!args) SWIG_fail;
13428 swig_obj[0] = args;
13429 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13430 if (!SWIG_IsOK(ecode1)) {
13431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13432 }
13433 arg1 = (PLINT)(val1);
13434 plstripd(arg1);
13435 resultobj = SWIG_Py_Void();
13436 return resultobj;
13437fail:
13438 return NULL;
13439}
13440
13441
13442SWIGINTERN PyObject *_wrap_plstyl(PyObject *self, PyObject *args) {
13443 PyObject *resultobj = 0;
13444 PLINT arg1 ;
13445 PLINT *arg2 = (PLINT *) 0 ;
13446 PLINT *arg3 = (PLINT *) 0 ;
13447 PyArrayObject *tmp1 = NULL ;
13448 PyArrayObject *tmp3 = NULL ;
13449 PyObject *swig_obj[2] ;
13450
13451 (void)self;
13452 if (!SWIG_Python_UnpackTuple(args, "plstyl", 2, 2, swig_obj)) SWIG_fail;
13453 {
13454 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
13455 if ( tmp1 == NULL )
13456 return NULL;
13457 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13458 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13459 }
13460 {
13461 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
13462 if ( tmp3 == NULL )
13463 return NULL;
13464 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13465 {
13466 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13467 return NULL;
13468 }
13469 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13470 }
13471 plstyl(arg1,(int const *)arg2,(int const *)arg3);
13472 resultobj = SWIG_Py_Void();
13473 {
13474 Py_CLEAR( tmp1 );
13475 }
13476 {
13477 Py_CLEAR( tmp3 );
13478 }
13479 return resultobj;
13480fail:
13481 {
13482 Py_CLEAR( tmp1 );
13483 }
13484 {
13485 Py_CLEAR( tmp3 );
13486 }
13487 return NULL;
13488}
13489
13490
13491SWIGINTERN PyObject *_wrap_plsvect(PyObject *self, PyObject *args) {
13492 PyObject *resultobj = 0;
13493 PLFLT *arg1 = (PLFLT *) 0 ;
13494 PLFLT *arg2 = (PLFLT *) 0 ;
13495 PLINT arg3 ;
13496 PLBOOL arg4 ;
13497 PyArrayObject *tmp1 = NULL ;
13498 PyArrayObject *tmp2 = NULL ;
13499 int val4 ;
13500 int ecode4 = 0 ;
13501 PyObject *swig_obj[3] ;
13502
13503 (void)self;
13504 if (!SWIG_Python_UnpackTuple(args, "plsvect", 3, 3, swig_obj)) SWIG_fail;
13505 {
13506 if ( swig_obj[0] != Py_None )
13507 {
13508 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13509 if ( tmp1 == NULL )
13510 return NULL;
13511 Alen = PyArray_DIMS( tmp1 )[0];
13512 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13513 }
13514 else
13515 {
13516 arg1 = NULL;
13517 Alen = 0;
13518 }
13519 }
13520 {
13521 if ( swig_obj[1] != Py_None )
13522 {
13523 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13524 if ( tmp2 == NULL )
13525 return NULL;
13526 if ( PyArray_DIMS( tmp2 )[0] != Alen )
13527 {
13528 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13529 return NULL;
13530 }
13531 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13532 arg3 = PyArray_DIMS( tmp2 )[0];
13533 }
13534 else
13535 {
13536 arg2 = NULL;
13537 arg3 = 0;
13538 }
13539 }
13540 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13541 if (!SWIG_IsOK(ecode4)) {
13542 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13543 }
13544 arg4 = (PLBOOL)(val4);
13545 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13546 resultobj = SWIG_Py_Void();
13547 {
13548 Py_CLEAR( tmp1 );
13549 }
13550 {
13551 Py_CLEAR( tmp2 );
13552 }
13553 return resultobj;
13554fail:
13555 {
13556 Py_CLEAR( tmp1 );
13557 }
13558 {
13559 Py_CLEAR( tmp2 );
13560 }
13561 return NULL;
13562}
13563
13564
13565SWIGINTERN PyObject *_wrap_plsvpa(PyObject *self, PyObject *args) {
13566 PyObject *resultobj = 0;
13567 PLFLT arg1 ;
13568 PLFLT arg2 ;
13569 PLFLT arg3 ;
13570 PLFLT arg4 ;
13571 double val1 ;
13572 int ecode1 = 0 ;
13573 double val2 ;
13574 int ecode2 = 0 ;
13575 double val3 ;
13576 int ecode3 = 0 ;
13577 double val4 ;
13578 int ecode4 = 0 ;
13579 PyObject *swig_obj[4] ;
13580
13581 (void)self;
13582 if (!SWIG_Python_UnpackTuple(args, "plsvpa", 4, 4, swig_obj)) SWIG_fail;
13583 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13584 if (!SWIG_IsOK(ecode1)) {
13585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13586 }
13587 arg1 = (PLFLT)(val1);
13588 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13589 if (!SWIG_IsOK(ecode2)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13591 }
13592 arg2 = (PLFLT)(val2);
13593 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13594 if (!SWIG_IsOK(ecode3)) {
13595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13596 }
13597 arg3 = (PLFLT)(val3);
13598 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13599 if (!SWIG_IsOK(ecode4)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13601 }
13602 arg4 = (PLFLT)(val4);
13603 plsvpa(arg1,arg2,arg3,arg4);
13604 resultobj = SWIG_Py_Void();
13605 return resultobj;
13606fail:
13607 return NULL;
13608}
13609
13610
13611SWIGINTERN PyObject *_wrap_plsxax(PyObject *self, PyObject *args) {
13612 PyObject *resultobj = 0;
13613 PLINT arg1 ;
13614 PLINT arg2 ;
13615 int val1 ;
13616 int ecode1 = 0 ;
13617 int val2 ;
13618 int ecode2 = 0 ;
13619 PyObject *swig_obj[2] ;
13620
13621 (void)self;
13622 if (!SWIG_Python_UnpackTuple(args, "plsxax", 2, 2, swig_obj)) SWIG_fail;
13623 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13624 if (!SWIG_IsOK(ecode1)) {
13625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13626 }
13627 arg1 = (PLINT)(val1);
13628 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13629 if (!SWIG_IsOK(ecode2)) {
13630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13631 }
13632 arg2 = (PLINT)(val2);
13633 plsxax(arg1,arg2);
13634 resultobj = SWIG_Py_Void();
13635 return resultobj;
13636fail:
13637 return NULL;
13638}
13639
13640
13641SWIGINTERN PyObject *_wrap_plsyax(PyObject *self, PyObject *args) {
13642 PyObject *resultobj = 0;
13643 PLINT arg1 ;
13644 PLINT arg2 ;
13645 int val1 ;
13646 int ecode1 = 0 ;
13647 int val2 ;
13648 int ecode2 = 0 ;
13649 PyObject *swig_obj[2] ;
13650
13651 (void)self;
13652 if (!SWIG_Python_UnpackTuple(args, "plsyax", 2, 2, swig_obj)) SWIG_fail;
13653 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13654 if (!SWIG_IsOK(ecode1)) {
13655 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13656 }
13657 arg1 = (PLINT)(val1);
13658 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13659 if (!SWIG_IsOK(ecode2)) {
13660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13661 }
13662 arg2 = (PLINT)(val2);
13663 plsyax(arg1,arg2);
13664 resultobj = SWIG_Py_Void();
13665 return resultobj;
13666fail:
13667 return NULL;
13668}
13669
13670
13671SWIGINTERN PyObject *_wrap_plsym(PyObject *self, PyObject *args) {
13672 PyObject *resultobj = 0;
13673 PLINT arg1 ;
13674 PLFLT *arg2 = (PLFLT *) 0 ;
13675 PLFLT *arg3 = (PLFLT *) 0 ;
13676 PLINT arg4 ;
13677 PyArrayObject *tmp1 = NULL ;
13678 PyArrayObject *tmp3 = NULL ;
13679 int val4 ;
13680 int ecode4 = 0 ;
13681 PyObject *swig_obj[3] ;
13682
13683 (void)self;
13684 if (!SWIG_Python_UnpackTuple(args, "plsym", 3, 3, swig_obj)) SWIG_fail;
13685 {
13686 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13687 if ( tmp1 == NULL )
13688 return NULL;
13689 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13690 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13691 }
13692 {
13693 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13694 if ( tmp3 == NULL )
13695 return NULL;
13696 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13697 {
13698 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13699 return NULL;
13700 }
13701 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13702 }
13703 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13704 if (!SWIG_IsOK(ecode4)) {
13705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13706 }
13707 arg4 = (PLINT)(val4);
13708 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13709 resultobj = SWIG_Py_Void();
13710 {
13711 Py_CLEAR( tmp1 );
13712 }
13713 {
13714 Py_CLEAR( tmp3 );
13715 }
13716 return resultobj;
13717fail:
13718 {
13719 Py_CLEAR( tmp1 );
13720 }
13721 {
13722 Py_CLEAR( tmp3 );
13723 }
13724 return NULL;
13725}
13726
13727
13728SWIGINTERN PyObject *_wrap_plszax(PyObject *self, PyObject *args) {
13729 PyObject *resultobj = 0;
13730 PLINT arg1 ;
13731 PLINT arg2 ;
13732 int val1 ;
13733 int ecode1 = 0 ;
13734 int val2 ;
13735 int ecode2 = 0 ;
13736 PyObject *swig_obj[2] ;
13737
13738 (void)self;
13739 if (!SWIG_Python_UnpackTuple(args, "plszax", 2, 2, swig_obj)) SWIG_fail;
13740 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13741 if (!SWIG_IsOK(ecode1)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13743 }
13744 arg1 = (PLINT)(val1);
13745 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13746 if (!SWIG_IsOK(ecode2)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13748 }
13749 arg2 = (PLINT)(val2);
13750 plszax(arg1,arg2);
13751 resultobj = SWIG_Py_Void();
13752 return resultobj;
13753fail:
13754 return NULL;
13755}
13756
13757
13758SWIGINTERN PyObject *_wrap_pltext(PyObject *self, PyObject *args) {
13759 PyObject *resultobj = 0;
13760
13761 (void)self;
13762 if (!SWIG_Python_UnpackTuple(args, "pltext", 0, 0, 0)) SWIG_fail;
13763 pltext();
13764 resultobj = SWIG_Py_Void();
13765 return resultobj;
13766fail:
13767 return NULL;
13768}
13769
13770
13771SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *self, PyObject *args) {
13772 PyObject *resultobj = 0;
13773 char *arg1 = (char *) 0 ;
13774 int res1 ;
13775 char *buf1 = 0 ;
13776 int alloc1 = 0 ;
13777 PyObject *swig_obj[1] ;
13778
13779 (void)self;
13780 if (!args) SWIG_fail;
13781 swig_obj[0] = args;
13782 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13783 if (!SWIG_IsOK(res1)) {
13784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13785 }
13786 arg1 = (char *)(buf1);
13787 pltimefmt((char const *)arg1);
13788 resultobj = SWIG_Py_Void();
13789 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13790 return resultobj;
13791fail:
13792 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13793 return NULL;
13794}
13795
13796
13797SWIGINTERN PyObject *_wrap_plvasp(PyObject *self, PyObject *args) {
13798 PyObject *resultobj = 0;
13799 PLFLT arg1 ;
13800 double val1 ;
13801 int ecode1 = 0 ;
13802 PyObject *swig_obj[1] ;
13803
13804 (void)self;
13805 if (!args) SWIG_fail;
13806 swig_obj[0] = args;
13807 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13808 if (!SWIG_IsOK(ecode1)) {
13809 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13810 }
13811 arg1 = (PLFLT)(val1);
13812 plvasp(arg1);
13813 resultobj = SWIG_Py_Void();
13814 return resultobj;
13815fail:
13816 return NULL;
13817}
13818
13819
13820SWIGINTERN PyObject *_wrap_plvect(PyObject *self, PyObject *args) {
13821 PyObject *resultobj = 0;
13822 PLFLT **arg1 = (PLFLT **) 0 ;
13823 PLFLT **arg2 = (PLFLT **) 0 ;
13824 PLINT arg3 ;
13825 PLINT arg4 ;
13826 PLFLT arg5 ;
13827 pltr_func arg6 = (pltr_func) 0 ;
13828 PLPointer arg7 = (PLPointer) 0 ;
13829 PyArrayObject *tmp1 = NULL ;
13830 PyArrayObject *tmp2 = NULL ;
13831 double val5 ;
13832 int ecode5 = 0 ;
13833 PyObject *swig_obj[5] ;
13834
13835 {
13836 python_pltr = 0;
13837 arg6 = NULL;
13838 }
13839 {
13840 arg7 = NULL;
13841 }
13842 (void)self;
13843 if (!SWIG_Python_UnpackTuple(args, "plvect", 3, 5, swig_obj)) SWIG_fail;
13844 {
13845 int i, size;
13846 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
13847 if ( tmp1 == NULL )
13848 return NULL;
13849 Xlen = PyArray_DIMS( tmp1 )[0];
13850 Ylen = PyArray_DIMS( tmp1 )[1];
13851 size = Ylen;
13852 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13853 for ( i = 0; i < Xlen; i++ )
13854 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13855 }
13856 {
13857 int i, size;
13858 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 2, 2 );
13859 if ( tmp2 == NULL )
13860 return NULL;
13861 if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13862 {
13863 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13864 return NULL;
13865 }
13866 arg3 = PyArray_DIMS( tmp2 )[0];
13867 arg4 = PyArray_DIMS( tmp2 )[1];
13868 size = arg4;
13869 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13870 for ( i = 0; i < arg3; i++ )
13871 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13872 }
13873 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
13874 if (!SWIG_IsOK(ecode5)) {
13875 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13876 }
13877 arg5 = (PLFLT)(val5);
13878 if (swig_obj[3]) {
13879 {
13880 // it must be a callable or None
13881 if ( swig_obj[3] == Py_None )
13882 {
13883 arg6 = NULL;
13884 }
13885 else
13886 {
13887 if ( !PyCallable_Check( (PyObject *) swig_obj[3] ) )
13888 {
13889 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13890 return NULL;
13891 }
13892 arg6 = marshal_pltr( swig_obj[3] );
13893 }
13894 }
13895 }
13896 if (swig_obj[4]) {
13897 {
13898 if ( swig_obj[4] == Py_None )
13899 arg7 = NULL;
13900 else
13901 {
13902 arg7 = marshal_PLPointer( swig_obj[4], 0 );
13903 }
13904 }
13905 }
13906 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13907 resultobj = SWIG_Py_Void();
13908 {
13909 Py_CLEAR( tmp1 );
13910 free( arg1 );
13911 }
13912 {
13913 Py_CLEAR( tmp2 );
13914 free( arg2 );
13915 }
13916 {
13917 cleanup_pltr();
13918 }
13919 {
13921 }
13922 return resultobj;
13923fail:
13924 {
13925 Py_CLEAR( tmp1 );
13926 free( arg1 );
13927 }
13928 {
13929 Py_CLEAR( tmp2 );
13930 free( arg2 );
13931 }
13932 {
13933 cleanup_pltr();
13934 }
13935 {
13937 }
13938 return NULL;
13939}
13940
13941
13942SWIGINTERN PyObject *_wrap_plvpas(PyObject *self, PyObject *args) {
13943 PyObject *resultobj = 0;
13944 PLFLT arg1 ;
13945 PLFLT arg2 ;
13946 PLFLT arg3 ;
13947 PLFLT arg4 ;
13948 PLFLT arg5 ;
13949 double val1 ;
13950 int ecode1 = 0 ;
13951 double val2 ;
13952 int ecode2 = 0 ;
13953 double val3 ;
13954 int ecode3 = 0 ;
13955 double val4 ;
13956 int ecode4 = 0 ;
13957 double val5 ;
13958 int ecode5 = 0 ;
13959 PyObject *swig_obj[5] ;
13960
13961 (void)self;
13962 if (!SWIG_Python_UnpackTuple(args, "plvpas", 5, 5, swig_obj)) SWIG_fail;
13963 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13964 if (!SWIG_IsOK(ecode1)) {
13965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
13966 }
13967 arg1 = (PLFLT)(val1);
13968 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13969 if (!SWIG_IsOK(ecode2)) {
13970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
13971 }
13972 arg2 = (PLFLT)(val2);
13973 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13974 if (!SWIG_IsOK(ecode3)) {
13975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
13976 }
13977 arg3 = (PLFLT)(val3);
13978 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13979 if (!SWIG_IsOK(ecode4)) {
13980 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
13981 }
13982 arg4 = (PLFLT)(val4);
13983 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
13984 if (!SWIG_IsOK(ecode5)) {
13985 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
13986 }
13987 arg5 = (PLFLT)(val5);
13988 plvpas(arg1,arg2,arg3,arg4,arg5);
13989 resultobj = SWIG_Py_Void();
13990 return resultobj;
13991fail:
13992 return NULL;
13993}
13994
13995
13996SWIGINTERN PyObject *_wrap_plvpor(PyObject *self, PyObject *args) {
13997 PyObject *resultobj = 0;
13998 PLFLT arg1 ;
13999 PLFLT arg2 ;
14000 PLFLT arg3 ;
14001 PLFLT arg4 ;
14002 double val1 ;
14003 int ecode1 = 0 ;
14004 double val2 ;
14005 int ecode2 = 0 ;
14006 double val3 ;
14007 int ecode3 = 0 ;
14008 double val4 ;
14009 int ecode4 = 0 ;
14010 PyObject *swig_obj[4] ;
14011
14012 (void)self;
14013 if (!SWIG_Python_UnpackTuple(args, "plvpor", 4, 4, swig_obj)) SWIG_fail;
14014 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14015 if (!SWIG_IsOK(ecode1)) {
14016 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
14017 }
14018 arg1 = (PLFLT)(val1);
14019 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14020 if (!SWIG_IsOK(ecode2)) {
14021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
14022 }
14023 arg2 = (PLFLT)(val2);
14024 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14025 if (!SWIG_IsOK(ecode3)) {
14026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
14027 }
14028 arg3 = (PLFLT)(val3);
14029 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14030 if (!SWIG_IsOK(ecode4)) {
14031 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
14032 }
14033 arg4 = (PLFLT)(val4);
14034 plvpor(arg1,arg2,arg3,arg4);
14035 resultobj = SWIG_Py_Void();
14036 return resultobj;
14037fail:
14038 return NULL;
14039}
14040
14041
14042SWIGINTERN PyObject *_wrap_plvsta(PyObject *self, PyObject *args) {
14043 PyObject *resultobj = 0;
14044
14045 (void)self;
14046 if (!SWIG_Python_UnpackTuple(args, "plvsta", 0, 0, 0)) SWIG_fail;
14047 plvsta();
14048 resultobj = SWIG_Py_Void();
14049 return resultobj;
14050fail:
14051 return NULL;
14052}
14053
14054
14055SWIGINTERN PyObject *_wrap_plw3d(PyObject *self, PyObject *args) {
14056 PyObject *resultobj = 0;
14057 PLFLT arg1 ;
14058 PLFLT arg2 ;
14059 PLFLT arg3 ;
14060 PLFLT arg4 ;
14061 PLFLT arg5 ;
14062 PLFLT arg6 ;
14063 PLFLT arg7 ;
14064 PLFLT arg8 ;
14065 PLFLT arg9 ;
14066 PLFLT arg10 ;
14067 PLFLT arg11 ;
14068 double val1 ;
14069 int ecode1 = 0 ;
14070 double val2 ;
14071 int ecode2 = 0 ;
14072 double val3 ;
14073 int ecode3 = 0 ;
14074 double val4 ;
14075 int ecode4 = 0 ;
14076 double val5 ;
14077 int ecode5 = 0 ;
14078 double val6 ;
14079 int ecode6 = 0 ;
14080 double val7 ;
14081 int ecode7 = 0 ;
14082 double val8 ;
14083 int ecode8 = 0 ;
14084 double val9 ;
14085 int ecode9 = 0 ;
14086 double val10 ;
14087 int ecode10 = 0 ;
14088 double val11 ;
14089 int ecode11 = 0 ;
14090 PyObject *swig_obj[11] ;
14091
14092 (void)self;
14093 if (!SWIG_Python_UnpackTuple(args, "plw3d", 11, 11, swig_obj)) SWIG_fail;
14094 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14095 if (!SWIG_IsOK(ecode1)) {
14096 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
14097 }
14098 arg1 = (PLFLT)(val1);
14099 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14100 if (!SWIG_IsOK(ecode2)) {
14101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
14102 }
14103 arg2 = (PLFLT)(val2);
14104 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14105 if (!SWIG_IsOK(ecode3)) {
14106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
14107 }
14108 arg3 = (PLFLT)(val3);
14109 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14110 if (!SWIG_IsOK(ecode4)) {
14111 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
14112 }
14113 arg4 = (PLFLT)(val4);
14114 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14115 if (!SWIG_IsOK(ecode5)) {
14116 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
14117 }
14118 arg5 = (PLFLT)(val5);
14119 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14120 if (!SWIG_IsOK(ecode6)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
14122 }
14123 arg6 = (PLFLT)(val6);
14124 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14125 if (!SWIG_IsOK(ecode7)) {
14126 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
14127 }
14128 arg7 = (PLFLT)(val7);
14129 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14130 if (!SWIG_IsOK(ecode8)) {
14131 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
14132 }
14133 arg8 = (PLFLT)(val8);
14134 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14135 if (!SWIG_IsOK(ecode9)) {
14136 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
14137 }
14138 arg9 = (PLFLT)(val9);
14139 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14140 if (!SWIG_IsOK(ecode10)) {
14141 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
14142 }
14143 arg10 = (PLFLT)(val10);
14144 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
14145 if (!SWIG_IsOK(ecode11)) {
14146 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
14147 }
14148 arg11 = (PLFLT)(val11);
14149 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14150 resultobj = SWIG_Py_Void();
14151 return resultobj;
14152fail:
14153 return NULL;
14154}
14155
14156
14157SWIGINTERN PyObject *_wrap_plwidth(PyObject *self, PyObject *args) {
14158 PyObject *resultobj = 0;
14159 PLFLT arg1 ;
14160 double val1 ;
14161 int ecode1 = 0 ;
14162 PyObject *swig_obj[1] ;
14163
14164 (void)self;
14165 if (!args) SWIG_fail;
14166 swig_obj[0] = args;
14167 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14168 if (!SWIG_IsOK(ecode1)) {
14169 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
14170 }
14171 arg1 = (PLFLT)(val1);
14172 plwidth(arg1);
14173 resultobj = SWIG_Py_Void();
14174 return resultobj;
14175fail:
14176 return NULL;
14177}
14178
14179
14180SWIGINTERN PyObject *_wrap_plwind(PyObject *self, PyObject *args) {
14181 PyObject *resultobj = 0;
14182 PLFLT arg1 ;
14183 PLFLT arg2 ;
14184 PLFLT arg3 ;
14185 PLFLT arg4 ;
14186 double val1 ;
14187 int ecode1 = 0 ;
14188 double val2 ;
14189 int ecode2 = 0 ;
14190 double val3 ;
14191 int ecode3 = 0 ;
14192 double val4 ;
14193 int ecode4 = 0 ;
14194 PyObject *swig_obj[4] ;
14195
14196 (void)self;
14197 if (!SWIG_Python_UnpackTuple(args, "plwind", 4, 4, swig_obj)) SWIG_fail;
14198 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14199 if (!SWIG_IsOK(ecode1)) {
14200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14201 }
14202 arg1 = (PLFLT)(val1);
14203 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14204 if (!SWIG_IsOK(ecode2)) {
14205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14206 }
14207 arg2 = (PLFLT)(val2);
14208 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14209 if (!SWIG_IsOK(ecode3)) {
14210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14211 }
14212 arg3 = (PLFLT)(val3);
14213 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14214 if (!SWIG_IsOK(ecode4)) {
14215 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14216 }
14217 arg4 = (PLFLT)(val4);
14218 plwind(arg1,arg2,arg3,arg4);
14219 resultobj = SWIG_Py_Void();
14220 return resultobj;
14221fail:
14222 return NULL;
14223}
14224
14225
14226SWIGINTERN PyObject *_wrap_plxormod(PyObject *self, PyObject *args) {
14227 PyObject *resultobj = 0;
14228 PLBOOL arg1 ;
14229 PLBOOL *arg2 = (PLBOOL *) 0 ;
14230 int val1 ;
14231 int ecode1 = 0 ;
14232 PLBOOL temp2 ;
14233 int res2 = SWIG_TMPOBJ ;
14234 PyObject *swig_obj[1] ;
14235
14236 arg2 = &temp2;
14237 (void)self;
14238 if (!args) SWIG_fail;
14239 swig_obj[0] = args;
14240 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
14241 if (!SWIG_IsOK(ecode1)) {
14242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14243 }
14244 arg1 = (PLBOOL)(val1);
14245 plxormod(arg1,arg2);
14246 resultobj = SWIG_Py_Void();
14247 if (SWIG_IsTmpObj(res2)) {
14248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
14249 } else {
14250 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14252 }
14253 return resultobj;
14254fail:
14255 return NULL;
14256}
14257
14258
14259SWIGINTERN PyObject *_wrap_plmap(PyObject *self, PyObject *args) {
14260 PyObject *resultobj = 0;
14261 mapform_func arg1 = (mapform_func) 0 ;
14262 char *arg2 = (char *) 0 ;
14263 PLFLT arg3 ;
14264 PLFLT arg4 ;
14265 PLFLT arg5 ;
14266 PLFLT arg6 ;
14267 int res2 ;
14268 char *buf2 = 0 ;
14269 int alloc2 = 0 ;
14270 double val3 ;
14271 int ecode3 = 0 ;
14272 double val4 ;
14273 int ecode4 = 0 ;
14274 double val5 ;
14275 int ecode5 = 0 ;
14276 double val6 ;
14277 int ecode6 = 0 ;
14278 PyObject *swig_obj[6] ;
14279
14280 (void)self;
14281 if (!SWIG_Python_UnpackTuple(args, "plmap", 6, 6, swig_obj)) SWIG_fail;
14282 {
14283 // it must be a callable or none
14284 if ( swig_obj[0] == Py_None )
14285 {
14286 arg1 = NULL;
14287 }
14288 else
14289 {
14290 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14291 {
14292 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14293 return NULL;
14294 }
14295 arg1 = marshal_mapform( swig_obj[0] );
14296 }
14297 }
14298 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14299 if (!SWIG_IsOK(res2)) {
14300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14301 }
14302 arg2 = (char *)(buf2);
14303 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14304 if (!SWIG_IsOK(ecode3)) {
14305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14306 }
14307 arg3 = (PLFLT)(val3);
14308 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14309 if (!SWIG_IsOK(ecode4)) {
14310 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14311 }
14312 arg4 = (PLFLT)(val4);
14313 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14314 if (!SWIG_IsOK(ecode5)) {
14315 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14316 }
14317 arg5 = (PLFLT)(val5);
14318 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14319 if (!SWIG_IsOK(ecode6)) {
14320 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14321 }
14322 arg6 = (PLFLT)(val6);
14323 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14324 resultobj = SWIG_Py_Void();
14325 {
14327 }
14328 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14329 return resultobj;
14330fail:
14331 {
14333 }
14334 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14335 return NULL;
14336}
14337
14338
14339SWIGINTERN PyObject *_wrap_plmapline(PyObject *self, PyObject *args) {
14340 PyObject *resultobj = 0;
14341 mapform_func arg1 = (mapform_func) 0 ;
14342 char *arg2 = (char *) 0 ;
14343 PLFLT arg3 ;
14344 PLFLT arg4 ;
14345 PLFLT arg5 ;
14346 PLFLT arg6 ;
14347 PLINT *arg7 = (PLINT *) 0 ;
14348 PLINT arg8 ;
14349 int res2 ;
14350 char *buf2 = 0 ;
14351 int alloc2 = 0 ;
14352 double val3 ;
14353 int ecode3 = 0 ;
14354 double val4 ;
14355 int ecode4 = 0 ;
14356 double val5 ;
14357 int ecode5 = 0 ;
14358 double val6 ;
14359 int ecode6 = 0 ;
14360 PyArrayObject *tmp7 = NULL ;
14361 PyObject *swig_obj[7] ;
14362
14363 (void)self;
14364 if (!SWIG_Python_UnpackTuple(args, "plmapline", 7, 7, swig_obj)) SWIG_fail;
14365 {
14366 // it must be a callable or none
14367 if ( swig_obj[0] == Py_None )
14368 {
14369 arg1 = NULL;
14370 }
14371 else
14372 {
14373 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14374 {
14375 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14376 return NULL;
14377 }
14378 arg1 = marshal_mapform( swig_obj[0] );
14379 }
14380 }
14381 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14382 if (!SWIG_IsOK(res2)) {
14383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
14384 }
14385 arg2 = (char *)(buf2);
14386 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14387 if (!SWIG_IsOK(ecode3)) {
14388 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
14389 }
14390 arg3 = (PLFLT)(val3);
14391 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14392 if (!SWIG_IsOK(ecode4)) {
14393 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
14394 }
14395 arg4 = (PLFLT)(val4);
14396 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14397 if (!SWIG_IsOK(ecode5)) {
14398 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
14399 }
14400 arg5 = (PLFLT)(val5);
14401 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14402 if (!SWIG_IsOK(ecode6)) {
14403 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14404 }
14405 arg6 = (PLFLT)(val6);
14406 {
14407 if ( swig_obj[6] != Py_None )
14408 {
14409 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14410 if ( tmp7 == NULL )
14411 return NULL;
14412 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14413 arg8 = PyArray_DIMS( tmp7 )[0];
14414 }
14415 else
14416 {
14417 arg7 = NULL;
14418 arg8 = 0;
14419 }
14420 }
14421 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14422 resultobj = SWIG_Py_Void();
14423 {
14425 }
14426 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14427 {
14428 Py_CLEAR( tmp7 );
14429 }
14430 return resultobj;
14431fail:
14432 {
14434 }
14435 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14436 {
14437 Py_CLEAR( tmp7 );
14438 }
14439 return NULL;
14440}
14441
14442
14443SWIGINTERN PyObject *_wrap_plmapstring(PyObject *self, PyObject *args) {
14444 PyObject *resultobj = 0;
14445 mapform_func arg1 = (mapform_func) 0 ;
14446 char *arg2 = (char *) 0 ;
14447 char *arg3 = (char *) 0 ;
14448 PLFLT arg4 ;
14449 PLFLT arg5 ;
14450 PLFLT arg6 ;
14451 PLFLT arg7 ;
14452 PLINT *arg8 = (PLINT *) 0 ;
14453 PLINT arg9 ;
14454 int res2 ;
14455 char *buf2 = 0 ;
14456 int alloc2 = 0 ;
14457 int res3 ;
14458 char *buf3 = 0 ;
14459 int alloc3 = 0 ;
14460 double val4 ;
14461 int ecode4 = 0 ;
14462 double val5 ;
14463 int ecode5 = 0 ;
14464 double val6 ;
14465 int ecode6 = 0 ;
14466 double val7 ;
14467 int ecode7 = 0 ;
14468 PyArrayObject *tmp8 = NULL ;
14469 PyObject *swig_obj[8] ;
14470
14471 (void)self;
14472 if (!SWIG_Python_UnpackTuple(args, "plmapstring", 8, 8, swig_obj)) SWIG_fail;
14473 {
14474 // it must be a callable or none
14475 if ( swig_obj[0] == Py_None )
14476 {
14477 arg1 = NULL;
14478 }
14479 else
14480 {
14481 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14482 {
14483 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14484 return NULL;
14485 }
14486 arg1 = marshal_mapform( swig_obj[0] );
14487 }
14488 }
14489 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14490 if (!SWIG_IsOK(res2)) {
14491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14492 }
14493 arg2 = (char *)(buf2);
14494 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
14495 if (!SWIG_IsOK(res3)) {
14496 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14497 }
14498 arg3 = (char *)(buf3);
14499 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14500 if (!SWIG_IsOK(ecode4)) {
14501 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14502 }
14503 arg4 = (PLFLT)(val4);
14504 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14505 if (!SWIG_IsOK(ecode5)) {
14506 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14507 }
14508 arg5 = (PLFLT)(val5);
14509 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14510 if (!SWIG_IsOK(ecode6)) {
14511 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14512 }
14513 arg6 = (PLFLT)(val6);
14514 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14515 if (!SWIG_IsOK(ecode7)) {
14516 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14517 }
14518 arg7 = (PLFLT)(val7);
14519 {
14520 if ( swig_obj[7] != Py_None )
14521 {
14522 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
14523 if ( tmp8 == NULL )
14524 return NULL;
14525 arg8 = (PLINT *) PyArray_DATA( tmp8 );
14526 arg9 = PyArray_DIMS( tmp8 )[0];
14527 }
14528 else
14529 {
14530 arg8 = NULL;
14531 arg9 = 0;
14532 }
14533 }
14534 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14535 resultobj = SWIG_Py_Void();
14536 {
14538 }
14539 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14540 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14541 {
14542 Py_CLEAR( tmp8 );
14543 }
14544 return resultobj;
14545fail:
14546 {
14548 }
14549 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14550 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14551 {
14552 Py_CLEAR( tmp8 );
14553 }
14554 return NULL;
14555}
14556
14557
14558SWIGINTERN PyObject *_wrap_plmaptex(PyObject *self, PyObject *args) {
14559 PyObject *resultobj = 0;
14560 mapform_func arg1 = (mapform_func) 0 ;
14561 char *arg2 = (char *) 0 ;
14562 PLFLT arg3 ;
14563 PLFLT arg4 ;
14564 PLFLT arg5 ;
14565 char *arg6 = (char *) 0 ;
14566 PLFLT arg7 ;
14567 PLFLT arg8 ;
14568 PLFLT arg9 ;
14569 PLFLT arg10 ;
14570 PLINT arg11 ;
14571 int res2 ;
14572 char *buf2 = 0 ;
14573 int alloc2 = 0 ;
14574 double val3 ;
14575 int ecode3 = 0 ;
14576 double val4 ;
14577 int ecode4 = 0 ;
14578 double val5 ;
14579 int ecode5 = 0 ;
14580 int res6 ;
14581 char *buf6 = 0 ;
14582 int alloc6 = 0 ;
14583 double val7 ;
14584 int ecode7 = 0 ;
14585 double val8 ;
14586 int ecode8 = 0 ;
14587 double val9 ;
14588 int ecode9 = 0 ;
14589 double val10 ;
14590 int ecode10 = 0 ;
14591 int val11 ;
14592 int ecode11 = 0 ;
14593 PyObject *swig_obj[11] ;
14594
14595 (void)self;
14596 if (!SWIG_Python_UnpackTuple(args, "plmaptex", 11, 11, swig_obj)) SWIG_fail;
14597 {
14598 // it must be a callable or none
14599 if ( swig_obj[0] == Py_None )
14600 {
14601 arg1 = NULL;
14602 }
14603 else
14604 {
14605 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14606 {
14607 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14608 return NULL;
14609 }
14610 arg1 = marshal_mapform( swig_obj[0] );
14611 }
14612 }
14613 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14614 if (!SWIG_IsOK(res2)) {
14615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14616 }
14617 arg2 = (char *)(buf2);
14618 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14619 if (!SWIG_IsOK(ecode3)) {
14620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14621 }
14622 arg3 = (PLFLT)(val3);
14623 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14624 if (!SWIG_IsOK(ecode4)) {
14625 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14626 }
14627 arg4 = (PLFLT)(val4);
14628 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14629 if (!SWIG_IsOK(ecode5)) {
14630 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14631 }
14632 arg5 = (PLFLT)(val5);
14633 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
14634 if (!SWIG_IsOK(res6)) {
14635 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14636 }
14637 arg6 = (char *)(buf6);
14638 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14639 if (!SWIG_IsOK(ecode7)) {
14640 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14641 }
14642 arg7 = (PLFLT)(val7);
14643 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14644 if (!SWIG_IsOK(ecode8)) {
14645 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14646 }
14647 arg8 = (PLFLT)(val8);
14648 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14649 if (!SWIG_IsOK(ecode9)) {
14650 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14651 }
14652 arg9 = (PLFLT)(val9);
14653 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14654 if (!SWIG_IsOK(ecode10)) {
14655 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14656 }
14657 arg10 = (PLFLT)(val10);
14658 ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
14659 if (!SWIG_IsOK(ecode11)) {
14660 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14661 }
14662 arg11 = (PLINT)(val11);
14663 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14664 resultobj = SWIG_Py_Void();
14665 {
14667 }
14668 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14669 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14670 return resultobj;
14671fail:
14672 {
14674 }
14675 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14676 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14677 return NULL;
14678}
14679
14680
14681SWIGINTERN PyObject *_wrap_plmapfill(PyObject *self, PyObject *args) {
14682 PyObject *resultobj = 0;
14683 mapform_func arg1 = (mapform_func) 0 ;
14684 char *arg2 = (char *) 0 ;
14685 PLFLT arg3 ;
14686 PLFLT arg4 ;
14687 PLFLT arg5 ;
14688 PLFLT arg6 ;
14689 PLINT *arg7 = (PLINT *) 0 ;
14690 PLINT arg8 ;
14691 int res2 ;
14692 char *buf2 = 0 ;
14693 int alloc2 = 0 ;
14694 double val3 ;
14695 int ecode3 = 0 ;
14696 double val4 ;
14697 int ecode4 = 0 ;
14698 double val5 ;
14699 int ecode5 = 0 ;
14700 double val6 ;
14701 int ecode6 = 0 ;
14702 PyArrayObject *tmp7 = NULL ;
14703 PyObject *swig_obj[7] ;
14704
14705 (void)self;
14706 if (!SWIG_Python_UnpackTuple(args, "plmapfill", 7, 7, swig_obj)) SWIG_fail;
14707 {
14708 // it must be a callable or none
14709 if ( swig_obj[0] == Py_None )
14710 {
14711 arg1 = NULL;
14712 }
14713 else
14714 {
14715 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14716 {
14717 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14718 return NULL;
14719 }
14720 arg1 = marshal_mapform( swig_obj[0] );
14721 }
14722 }
14723 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14724 if (!SWIG_IsOK(res2)) {
14725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14726 }
14727 arg2 = (char *)(buf2);
14728 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14729 if (!SWIG_IsOK(ecode3)) {
14730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14731 }
14732 arg3 = (PLFLT)(val3);
14733 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14734 if (!SWIG_IsOK(ecode4)) {
14735 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14736 }
14737 arg4 = (PLFLT)(val4);
14738 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14739 if (!SWIG_IsOK(ecode5)) {
14740 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14741 }
14742 arg5 = (PLFLT)(val5);
14743 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14744 if (!SWIG_IsOK(ecode6)) {
14745 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14746 }
14747 arg6 = (PLFLT)(val6);
14748 {
14749 if ( swig_obj[6] != Py_None )
14750 {
14751 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14752 if ( tmp7 == NULL )
14753 return NULL;
14754 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14755 arg8 = PyArray_DIMS( tmp7 )[0];
14756 }
14757 else
14758 {
14759 arg7 = NULL;
14760 arg8 = 0;
14761 }
14762 }
14763 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14764 resultobj = SWIG_Py_Void();
14765 {
14767 }
14768 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14769 {
14770 Py_CLEAR( tmp7 );
14771 }
14772 return resultobj;
14773fail:
14774 {
14776 }
14777 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14778 {
14779 Py_CLEAR( tmp7 );
14780 }
14781 return NULL;
14782}
14783
14784
14785SWIGINTERN PyObject *_wrap_plmeridians(PyObject *self, PyObject *args) {
14786 PyObject *resultobj = 0;
14787 mapform_func arg1 = (mapform_func) 0 ;
14788 PLFLT arg2 ;
14789 PLFLT arg3 ;
14790 PLFLT arg4 ;
14791 PLFLT arg5 ;
14792 PLFLT arg6 ;
14793 PLFLT arg7 ;
14794 double val2 ;
14795 int ecode2 = 0 ;
14796 double val3 ;
14797 int ecode3 = 0 ;
14798 double val4 ;
14799 int ecode4 = 0 ;
14800 double val5 ;
14801 int ecode5 = 0 ;
14802 double val6 ;
14803 int ecode6 = 0 ;
14804 double val7 ;
14805 int ecode7 = 0 ;
14806 PyObject *swig_obj[7] ;
14807
14808 (void)self;
14809 if (!SWIG_Python_UnpackTuple(args, "plmeridians", 7, 7, swig_obj)) SWIG_fail;
14810 {
14811 // it must be a callable or none
14812 if ( swig_obj[0] == Py_None )
14813 {
14814 arg1 = NULL;
14815 }
14816 else
14817 {
14818 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14819 {
14820 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14821 return NULL;
14822 }
14823 arg1 = marshal_mapform( swig_obj[0] );
14824 }
14825 }
14826 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14827 if (!SWIG_IsOK(ecode2)) {
14828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14829 }
14830 arg2 = (PLFLT)(val2);
14831 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14832 if (!SWIG_IsOK(ecode3)) {
14833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14834 }
14835 arg3 = (PLFLT)(val3);
14836 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14837 if (!SWIG_IsOK(ecode4)) {
14838 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14839 }
14840 arg4 = (PLFLT)(val4);
14841 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14842 if (!SWIG_IsOK(ecode5)) {
14843 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14844 }
14845 arg5 = (PLFLT)(val5);
14846 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14847 if (!SWIG_IsOK(ecode6)) {
14848 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14849 }
14850 arg6 = (PLFLT)(val6);
14851 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14852 if (!SWIG_IsOK(ecode7)) {
14853 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14854 }
14855 arg7 = (PLFLT)(val7);
14856 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14857 resultobj = SWIG_Py_Void();
14858 {
14860 }
14861 return resultobj;
14862fail:
14863 {
14865 }
14866 return NULL;
14867}
14868
14869
14870SWIGINTERN PyObject *_wrap_plimage(PyObject *self, PyObject *args) {
14871 PyObject *resultobj = 0;
14872 PLFLT **arg1 = (PLFLT **) 0 ;
14873 PLINT arg2 ;
14874 PLINT arg3 ;
14875 PLFLT arg4 ;
14876 PLFLT arg5 ;
14877 PLFLT arg6 ;
14878 PLFLT arg7 ;
14879 PLFLT arg8 ;
14880 PLFLT arg9 ;
14881 PLFLT arg10 ;
14882 PLFLT arg11 ;
14883 PLFLT arg12 ;
14884 PLFLT arg13 ;
14885 PyArrayObject *tmp1 = NULL ;
14886 double val4 ;
14887 int ecode4 = 0 ;
14888 double val5 ;
14889 int ecode5 = 0 ;
14890 double val6 ;
14891 int ecode6 = 0 ;
14892 double val7 ;
14893 int ecode7 = 0 ;
14894 double val8 ;
14895 int ecode8 = 0 ;
14896 double val9 ;
14897 int ecode9 = 0 ;
14898 double val10 ;
14899 int ecode10 = 0 ;
14900 double val11 ;
14901 int ecode11 = 0 ;
14902 double val12 ;
14903 int ecode12 = 0 ;
14904 double val13 ;
14905 int ecode13 = 0 ;
14906 PyObject *swig_obj[11] ;
14907
14908 (void)self;
14909 if (!SWIG_Python_UnpackTuple(args, "plimage", 11, 11, swig_obj)) SWIG_fail;
14910 {
14911 int i, size;
14912 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14913 if ( tmp1 == NULL )
14914 return NULL;
14915 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14916 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14917 size = arg3;
14918 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14919 for ( i = 0; i < arg2; i++ )
14920 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14921 }
14922 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14923 if (!SWIG_IsOK(ecode4)) {
14924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14925 }
14926 arg4 = (PLFLT)(val4);
14927 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14928 if (!SWIG_IsOK(ecode5)) {
14929 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14930 }
14931 arg5 = (PLFLT)(val5);
14932 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14933 if (!SWIG_IsOK(ecode6)) {
14934 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14935 }
14936 arg6 = (PLFLT)(val6);
14937 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14938 if (!SWIG_IsOK(ecode7)) {
14939 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14940 }
14941 arg7 = (PLFLT)(val7);
14942 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14943 if (!SWIG_IsOK(ecode8)) {
14944 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14945 }
14946 arg8 = (PLFLT)(val8);
14947 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14948 if (!SWIG_IsOK(ecode9)) {
14949 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14950 }
14951 arg9 = (PLFLT)(val9);
14952 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14953 if (!SWIG_IsOK(ecode10)) {
14954 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14955 }
14956 arg10 = (PLFLT)(val10);
14957 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
14958 if (!SWIG_IsOK(ecode11)) {
14959 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
14960 }
14961 arg11 = (PLFLT)(val11);
14962 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
14963 if (!SWIG_IsOK(ecode12)) {
14964 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
14965 }
14966 arg12 = (PLFLT)(val12);
14967 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
14968 if (!SWIG_IsOK(ecode13)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
14970 }
14971 arg13 = (PLFLT)(val13);
14972 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14973 resultobj = SWIG_Py_Void();
14974 {
14975 Py_CLEAR( tmp1 );
14976 free( arg1 );
14977 }
14978 return resultobj;
14979fail:
14980 {
14981 Py_CLEAR( tmp1 );
14982 free( arg1 );
14983 }
14984 return NULL;
14985}
14986
14987
14988SWIGINTERN PyObject *_wrap_plimagefr(PyObject *self, PyObject *args) {
14989 PyObject *resultobj = 0;
14990 PLFLT **arg1 = (PLFLT **) 0 ;
14991 PLINT arg2 ;
14992 PLINT arg3 ;
14993 PLFLT arg4 ;
14994 PLFLT arg5 ;
14995 PLFLT arg6 ;
14996 PLFLT arg7 ;
14997 PLFLT arg8 ;
14998 PLFLT arg9 ;
14999 PLFLT arg10 ;
15000 PLFLT arg11 ;
15001 pltr_func arg12 = (pltr_func) 0 ;
15002 PLPointer arg13 = (PLPointer) 0 ;
15003 PyArrayObject *tmp1 = NULL ;
15004 double val4 ;
15005 int ecode4 = 0 ;
15006 double val5 ;
15007 int ecode5 = 0 ;
15008 double val6 ;
15009 int ecode6 = 0 ;
15010 double val7 ;
15011 int ecode7 = 0 ;
15012 double val8 ;
15013 int ecode8 = 0 ;
15014 double val9 ;
15015 int ecode9 = 0 ;
15016 double val10 ;
15017 int ecode10 = 0 ;
15018 double val11 ;
15019 int ecode11 = 0 ;
15020 PyObject *swig_obj[11] ;
15021
15022 {
15023 python_pltr = 0;
15024 arg12 = NULL;
15025 }
15026 {
15027 arg13 = NULL;
15028 }
15029 (void)self;
15030 if (!SWIG_Python_UnpackTuple(args, "plimagefr", 9, 11, swig_obj)) SWIG_fail;
15031 {
15032 int i, size;
15033 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15034 if ( tmp1 == NULL )
15035 return NULL;
15036 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15037 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15038 size = arg3;
15039 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15040 for ( i = 0; i < arg2; i++ )
15041 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15042 }
15043 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
15044 if (!SWIG_IsOK(ecode4)) {
15045 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15046 }
15047 arg4 = (PLFLT)(val4);
15048 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
15049 if (!SWIG_IsOK(ecode5)) {
15050 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15051 }
15052 arg5 = (PLFLT)(val5);
15053 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
15054 if (!SWIG_IsOK(ecode6)) {
15055 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15056 }
15057 arg6 = (PLFLT)(val6);
15058 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
15059 if (!SWIG_IsOK(ecode7)) {
15060 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15061 }
15062 arg7 = (PLFLT)(val7);
15063 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
15064 if (!SWIG_IsOK(ecode8)) {
15065 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15066 }
15067 arg8 = (PLFLT)(val8);
15068 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
15069 if (!SWIG_IsOK(ecode9)) {
15070 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15071 }
15072 arg9 = (PLFLT)(val9);
15073 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
15074 if (!SWIG_IsOK(ecode10)) {
15075 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15076 }
15077 arg10 = (PLFLT)(val10);
15078 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
15079 if (!SWIG_IsOK(ecode11)) {
15080 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15081 }
15082 arg11 = (PLFLT)(val11);
15083 if (swig_obj[9]) {
15084 {
15085 // it must be a callable or None
15086 if ( swig_obj[9] == Py_None )
15087 {
15088 arg12 = NULL;
15089 }
15090 else
15091 {
15092 if ( !PyCallable_Check( (PyObject *) swig_obj[9] ) )
15093 {
15094 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
15095 return NULL;
15096 }
15097 arg12 = marshal_pltr( swig_obj[9] );
15098 }
15099 }
15100 }
15101 if (swig_obj[10]) {
15102 {
15103 if ( swig_obj[10] == Py_None )
15104 arg13 = NULL;
15105 else
15106 {
15107 arg13 = marshal_PLPointer( swig_obj[10], 1 );
15108 }
15109 }
15110 }
15111 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15112 resultobj = SWIG_Py_Void();
15113 {
15114 Py_CLEAR( tmp1 );
15115 free( arg1 );
15116 }
15117 {
15118 cleanup_pltr();
15119 }
15120 {
15122 }
15123 return resultobj;
15124fail:
15125 {
15126 Py_CLEAR( tmp1 );
15127 free( arg1 );
15128 }
15129 {
15130 cleanup_pltr();
15131 }
15132 {
15134 }
15135 return NULL;
15136}
15137
15138
15139SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *self, PyObject *args) {
15140 PyObject *resultobj = 0;
15141
15142 (void)self;
15143 if (!SWIG_Python_UnpackTuple(args, "plClearOpts", 0, 0, 0)) SWIG_fail;
15144 plClearOpts();
15145 resultobj = SWIG_Py_Void();
15146 return resultobj;
15147fail:
15148 return NULL;
15149}
15150
15151
15152SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *self, PyObject *args) {
15153 PyObject *resultobj = 0;
15154
15155 (void)self;
15156 if (!SWIG_Python_UnpackTuple(args, "plResetOpts", 0, 0, 0)) SWIG_fail;
15157 plResetOpts();
15158 resultobj = SWIG_Py_Void();
15159 return resultobj;
15160fail:
15161 return NULL;
15162}
15163
15164
15165SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *self, PyObject *args) {
15166 PyObject *resultobj = 0;
15167 char *arg1 = (char *) 0 ;
15168 char *arg2 = (char *) 0 ;
15169 int res1 ;
15170 char *buf1 = 0 ;
15171 int alloc1 = 0 ;
15172 int res2 ;
15173 char *buf2 = 0 ;
15174 int alloc2 = 0 ;
15175 PyObject *swig_obj[2] ;
15176
15177 (void)self;
15178 if (!SWIG_Python_UnpackTuple(args, "plSetUsage", 2, 2, swig_obj)) SWIG_fail;
15179 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
15180 if (!SWIG_IsOK(res1)) {
15181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
15182 }
15183 arg1 = (char *)(buf1);
15184 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
15185 if (!SWIG_IsOK(res2)) {
15186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
15187 }
15188 arg2 = (char *)(buf2);
15189 plSetUsage((char const *)arg1,(char const *)arg2);
15190 resultobj = SWIG_Py_Void();
15191 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15192 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15193 return resultobj;
15194fail:
15195 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15196 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15197 return NULL;
15198}
15199
15200
15201SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *self, PyObject *args) {
15202 PyObject *resultobj = 0;
15203
15204 (void)self;
15205 if (!SWIG_Python_UnpackTuple(args, "plOptUsage", 0, 0, 0)) SWIG_fail;
15206 plOptUsage();
15207 resultobj = SWIG_Py_Void();
15208 return resultobj;
15209fail:
15210 return NULL;
15211}
15212
15213
15214SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *self, PyObject *args) {
15215 PyObject *resultobj = 0;
15216 PLFLT **arg1 = (PLFLT **) 0 ;
15217 PLINT arg2 ;
15218 PLINT arg3 ;
15219 PLFLT *arg4 = (PLFLT *) 0 ;
15220 PLFLT *arg5 = (PLFLT *) 0 ;
15221 PyArrayObject *tmp1 = NULL ;
15222 PLFLT temp4 ;
15223 int res4 = SWIG_TMPOBJ ;
15224 PLFLT temp5 ;
15225 int res5 = SWIG_TMPOBJ ;
15226 PyObject *swig_obj[1] ;
15227
15228 arg4 = &temp4;
15229 arg5 = &temp5;
15230 (void)self;
15231 if (!args) SWIG_fail;
15232 swig_obj[0] = args;
15233 {
15234 int i, size;
15235 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15236 if ( tmp1 == NULL )
15237 return NULL;
15238 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15239 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15240 size = arg3;
15241 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15242 for ( i = 0; i < arg2; i++ )
15243 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15244 }
15245 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
15246 resultobj = SWIG_Py_Void();
15247 if (SWIG_IsTmpObj(res4)) {
15248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
15249 } else {
15250 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15252 }
15253 if (SWIG_IsTmpObj(res5)) {
15254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
15255 } else {
15256 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15257 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
15258 }
15259 {
15260 Py_CLEAR( tmp1 );
15261 free( arg1 );
15262 }
15263 return resultobj;
15264fail:
15265 {
15266 Py_CLEAR( tmp1 );
15267 free( arg1 );
15268 }
15269 return NULL;
15270}
15271
15272
15273SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *self, PyObject *args) {
15274 PyObject *resultobj = 0;
15275 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15276 void *argp1 = 0 ;
15277 int res1 = 0 ;
15278 PyObject *swig_obj[1] ;
15279 PLINT result;
15280
15281 (void)self;
15282 if (!args) SWIG_fail;
15283 swig_obj[0] = args;
15284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15285 if (!SWIG_IsOK(res1)) {
15286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15287 }
15288 arg1 = (PLGraphicsIn *)(argp1);
15289 result = (PLINT)plGetCursor(arg1);
15290 resultobj = SWIG_From_int((int)(result));
15291 return resultobj;
15292fail:
15293 return NULL;
15294}
15295
15296
15297static PyMethodDef SwigMethods[] = {
15298 { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
15299 { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
15300 { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
15301 { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
15302 { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_O, NULL},
15303 { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
15304 { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_O, NULL},
15305 { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
15306 { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_O, NULL},
15307 { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
15308 { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_O, NULL},
15309 { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
15310 { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_O, NULL},
15311 { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
15312 { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_O, NULL},
15313 { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
15314 { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_O, NULL},
15315 { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
15316 { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_O, NULL},
15317 { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
15318 { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_O, NULL},
15319 { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
15320 { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_O, NULL},
15321 { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
15322 { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_O, NULL},
15323 { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
15324 { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_O, NULL},
15325 { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_NOARGS, NULL},
15326 { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_O, NULL},
15327 { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_O, NULL},
15328 { "PLGraphicsIn_swiginit", PLGraphicsIn_swiginit, METH_VARARGS, NULL},
15329 { "plsxwin", _wrap_plsxwin, METH_O, NULL},
15330 { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, "\n"
15331 "Set format of numerical label for contours\n"
15332 "\n"
15333 "DESCRIPTION:\n"
15334 "\n"
15335 " Set format of numerical label for contours.\n"
15336 "\n"
15337 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15338 "\n"
15339 " This function is used example 9.\n"
15340 "\n"
15341 "\n"
15342 "\n"
15343 "SYNOPSIS:\n"
15344 "\n"
15345 "pl_setcontlabelformat(lexp, sigdig)\n"
15346 "\n"
15347 "ARGUMENTS:\n"
15348 "\n"
15349 " lexp (PLINT, input) : If the contour numerical label is greater\n"
15350 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15351 " format is used. Default value of lexp is 4.\n"
15352 "\n"
15353 " sigdig (PLINT, input) : Number of significant digits. Default\n"
15354 " value is 2.\n"
15355 "\n"
15356 ""},
15357 { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, "\n"
15358 "Set parameters of contour labelling other than format of numerical label\n"
15359 "\n"
15360 "DESCRIPTION:\n"
15361 "\n"
15362 " Set parameters of contour labelling other than those handled by\n"
15363 " pl_setcontlabelformat.\n"
15364 "\n"
15365 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15366 "\n"
15367 " This function is used in example 9.\n"
15368 "\n"
15369 "\n"
15370 "\n"
15371 "SYNOPSIS:\n"
15372 "\n"
15373 "pl_setcontlabelparam(offset, size, spacing, active)\n"
15374 "\n"
15375 "ARGUMENTS:\n"
15376 "\n"
15377 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15378 " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
15379 "\n"
15380 " size (PLFLT, input) : Font height for contour labels (normalized).\n"
15381 " Default value is 0.3.\n"
15382 "\n"
15383 " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
15384 " Default value is 0.1.\n"
15385 "\n"
15386 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15387 " contour labels on. Default is off (0).\n"
15388 "\n"
15389 ""},
15390 { "pladv", _wrap_pladv, METH_O, "\n"
15391 "Advance the (sub-)page\n"
15392 "\n"
15393 "DESCRIPTION:\n"
15394 "\n"
15395 " Advances to the next subpage if sub=0, performing a page advance if\n"
15396 " there are no remaining subpages on the current page. If subpages\n"
15397 " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15398 " PLplot switches to the specified subpage. Note that this allows you\n"
15399 " to overwrite a plot on the specified subpage; if this is not what you\n"
15400 " intended, use pleop followed by plbop to first advance the page. This\n"
15401 " routine is called automatically (with page=0) by plenv, but if plenv\n"
15402 " is not used, pladv must be called after initializing PLplot but before\n"
15403 " defining the viewport.\n"
15404 "\n"
15405 " Redacted form: pladv(page)\n"
15406 "\n"
15407 " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
15408 " 29, and 31.\n"
15409 "\n"
15410 "\n"
15411 "\n"
15412 "SYNOPSIS:\n"
15413 "\n"
15414 "pladv(page)\n"
15415 "\n"
15416 "ARGUMENTS:\n"
15417 "\n"
15418 " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15419 " in the top left corner and increasing along the rows) to which to\n"
15420 " advance. Set to zero to advance to the next subpage (or to the\n"
15421 " next page if subpages are not being used).\n"
15422 "\n"
15423 ""},
15424 { "plarc", _wrap_plarc, METH_VARARGS, "\n"
15425 "Draw a circular or elliptical arc\n"
15426 "\n"
15427 "DESCRIPTION:\n"
15428 "\n"
15429 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15430 " semiminor axis b, starting at angle1 and ending at angle2.\n"
15431 "\n"
15432 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15433 " fill)\n"
15434 "\n"
15435 "\n"
15436 " This function is used in examples 3 and 27.\n"
15437 "\n"
15438 "\n"
15439 "\n"
15440 "SYNOPSIS:\n"
15441 "\n"
15442 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15443 "\n"
15444 "ARGUMENTS:\n"
15445 "\n"
15446 " x (PLFLT, input) : X coordinate of arc center.\n"
15447 "\n"
15448 " y (PLFLT, input) : Y coordinate of arc center.\n"
15449 "\n"
15450 " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15451 "\n"
15452 " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15453 "\n"
15454 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15455 " semimajor axis.\n"
15456 "\n"
15457 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15458 " semimajor axis.\n"
15459 "\n"
15460 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15461 " X-axis.\n"
15462 "\n"
15463 " fill (PLBOOL, input) : Draw a filled arc.\n"
15464 "\n"
15465 ""},
15466 { "plaxes", _wrap_plaxes, METH_VARARGS, "\n"
15467 "Draw a box with axes, etc. with arbitrary origin\n"
15468 "\n"
15469 "DESCRIPTION:\n"
15470 "\n"
15471 " Draws a box around the currently defined viewport with arbitrary\n"
15472 " world-coordinate origin specified by x0 and y0 and labels it with\n"
15473 " world coordinate values appropriate to the window. Thus plaxes should\n"
15474 " only be called after defining both viewport and window. The ascii\n"
15475 " character strings xopt and yopt specify how the box should be drawn as\n"
15476 " described below. If ticks and/or subticks are to be drawn for a\n"
15477 " particular axis, the tick intervals and number of subintervals may be\n"
15478 " specified explicitly, or they may be defaulted by setting the\n"
15479 " appropriate arguments to zero.\n"
15480 "\n"
15481 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15482 " ytick, nysub)\n"
15483 "\n"
15484 "\n"
15485 " This function is not used in any examples.\n"
15486 "\n"
15487 "\n"
15488 "\n"
15489 "SYNOPSIS:\n"
15490 "\n"
15491 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15492 "\n"
15493 "ARGUMENTS:\n"
15494 "\n"
15495 " x0 (PLFLT, input) : World X coordinate of origin.\n"
15496 "\n"
15497 " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15498 "\n"
15499 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15500 " options for the x axis. The string can include any combination of\n"
15501 " the following letters (upper or lower case) in any order: a: Draws\n"
15502 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15503 " (x=0).\n"
15504 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15505 " c: Draws top (X) or right (Y) edge of frame.\n"
15506 " d: Plot labels as date / time. Values are assumed to be\n"
15507 " seconds since the epoch (as used by gmtime).\n"
15508 " f: Always use fixed point numeric labels.\n"
15509 " g: Draws a grid at the major tick interval.\n"
15510 " h: Draws a grid at the minor tick interval.\n"
15511 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15512 " inwards.\n"
15513 " l: Labels axis logarithmically. This only affects the labels,\n"
15514 " not the data, and so it is necessary to compute the logarithms\n"
15515 " of data points before passing them to any of the drawing\n"
15516 " routines.\n"
15517 " m: Writes numeric labels at major tick intervals in the\n"
15518 " unconventional location (above box for X, right of box for Y).\n"
15519 " n: Writes numeric labels at major tick intervals in the\n"
15520 " conventional location (below box for X, left of box for Y).\n"
15521 " o: Use custom labelling function to generate axis label text.\n"
15522 " The custom labelling function can be defined with the\n"
15523 " plslabelfunc command.\n"
15524 " s: Enables subticks between major ticks, only valid if t is\n"
15525 " also specified.\n"
15526 " t: Draws major ticks.\n"
15527 " u: Exactly like \"b\" except don't draw edge line.\n"
15528 " w: Exactly like \"c\" except don't draw edge line.\n"
15529 " x: Exactly like \"t\" (including the side effect of the\n"
15530 " numerical labels for the major ticks) except exclude drawing\n"
15531 " the major and minor tick marks.\n"
15532 "\n"
15533 "\n"
15534 " xtick (PLFLT, input) : World coordinate interval between major\n"
15535 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15536 " generates a suitable tick interval.\n"
15537 "\n"
15538 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15539 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15540 " generates a suitable minor tick interval.\n"
15541 "\n"
15542 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15543 " options for the y axis. The string can include any combination of\n"
15544 " the letters defined above for xopt, and in addition may contain:\n"
15545 " v: Write numeric labels for the y axis parallel to the base of the\n"
15546 " graph, rather than parallel to the axis.\n"
15547 "\n"
15548 "\n"
15549 " ytick (PLFLT, input) : World coordinate interval between major\n"
15550 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15551 " generates a suitable tick interval.\n"
15552 "\n"
15553 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15554 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15555 " generates a suitable minor tick interval.\n"
15556 "\n"
15557 ""},
15558 { "plbin", _wrap_plbin, METH_VARARGS, "\n"
15559 "Plot a histogram from binned data\n"
15560 "\n"
15561 "DESCRIPTION:\n"
15562 "\n"
15563 " Plots a histogram consisting of nbin bins. The value associated with\n"
15564 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15565 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15566 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15567 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15568 " placed midway between the values in the x vector. Also see plhist for\n"
15569 " drawing histograms from unbinned data.\n"
15570 "\n"
15571 " Redacted form: General: plbin(x, y, opt)\n"
15572 " Python: plbin(nbin, x, y, opt)\n"
15573 "\n"
15574 "\n"
15575 " This function is not used in any examples.\n"
15576 "\n"
15577 "\n"
15578 "\n"
15579 "SYNOPSIS:\n"
15580 "\n"
15581 "plbin(nbin, x, y, opt)\n"
15582 "\n"
15583 "ARGUMENTS:\n"
15584 "\n"
15585 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15586 " and y vectors.)\n"
15587 "\n"
15588 " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15589 " with bins. These must form a strictly increasing sequence.\n"
15590 "\n"
15591 " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15592 " proportional to the number of points in each bin. This is a PLFLT\n"
15593 " (instead of PLINT) vector so as to allow histograms of\n"
15594 " probabilities, etc.\n"
15595 "\n"
15596 " opt (PLINT, input) : Is a combination of several flags:\n"
15597 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15598 " outer bins are expanded to fill up the entire x-axis and bins of\n"
15599 " zero height are simply drawn.\n"
15600 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15601 " between the x values. If the values in x are equally spaced,\n"
15602 " the values are the center values of the bins.\n"
15603 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15604 " size as the ones inside.\n"
15605 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15606 " (there is a gap for such bins).\n"
15607 "\n"
15608 ""},
15609 { "plbtime", _wrap_plbtime, METH_O, "\n"
15610 "Calculate broken-down time from continuous time for the current stream\n"
15611 "\n"
15612 "DESCRIPTION:\n"
15613 "\n"
15614 " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15615 " continuous time, ctime for the current stream. This function is the\n"
15616 " inverse of plctime.\n"
15617 "\n"
15618 " The PLplot definition of broken-down time is a calendar time that\n"
15619 " completely ignores all time zone offsets, i.e., it is the user's\n"
15620 " responsibility to apply those offsets (if so desired) before using the\n"
15621 " PLplot time API. By default broken-down time is defined using the\n"
15622 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15623 " continuous time is defined as the number of seconds since the Unix\n"
15624 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15625 " broken-down and continuous time are possible, see plconfigtime.\n"
15626 "\n"
15627 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15628 " ctime)\n"
15629 "\n"
15630 "\n"
15631 " This function is used in example 29.\n"
15632 "\n"
15633 "\n"
15634 "\n"
15635 "SYNOPSIS:\n"
15636 "\n"
15637 "plbtime(year, month, day, hour, min, sec, ctime)\n"
15638 "\n"
15639 "ARGUMENTS:\n"
15640 "\n"
15641 " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15642 " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15643 " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15644 " BCE, etc.)\n"
15645 "\n"
15646 " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15647 " the year in the range from 0 (January) to 11 (December).\n"
15648 "\n"
15649 " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15650 " month in the range from 1 to 31.\n"
15651 "\n"
15652 " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15653 " day in the range from 0 to 23.\n"
15654 "\n"
15655 " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15656 " hour in the range from 0 to 59\n"
15657 "\n"
15658 " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15659 " minute in range from 0. to 60.\n"
15660 "\n"
15661 " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
15662 " time is calculated.\n"
15663 "\n"
15664 ""},
15665 { "plbop", _wrap_plbop, METH_NOARGS, "\n"
15666 "Begin a new page\n"
15667 "\n"
15668 "DESCRIPTION:\n"
15669 "\n"
15670 " Begins a new page. For a file driver, the output file is opened if\n"
15671 " necessary. Advancing the page via pleop and plbop is useful when a\n"
15672 " page break is desired at a particular point when plotting to subpages.\n"
15673 " Another use for pleop and plbop is when plotting pages to different\n"
15674 " files, since you can manually set the file name by calling plsfnam\n"
15675 " after the call to pleop. (In fact some drivers may only support a\n"
15676 " single page per file, making this a necessity.) One way to handle\n"
15677 " this case automatically is to page advance via pladv, but enable\n"
15678 " familying (see plsfam) with a small limit on the file size so that a\n"
15679 " new family member file will be created on each page break.\n"
15680 "\n"
15681 " Redacted form: plbop()\n"
15682 "\n"
15683 " This function is used in examples 2 and 20.\n"
15684 "\n"
15685 "\n"
15686 "\n"
15687 "SYNOPSIS:\n"
15688 "\n"
15689 "plbop()\n"
15690 "\n"
15691 ""},
15692 { "plbox", _wrap_plbox, METH_VARARGS, "\n"
15693 "Draw a box with axes, etc\n"
15694 "\n"
15695 "DESCRIPTION:\n"
15696 "\n"
15697 " Draws a box around the currently defined viewport, and labels it with\n"
15698 " world coordinate values appropriate to the window. Thus plbox should\n"
15699 " only be called after defining both viewport and window. The ascii\n"
15700 " character strings xopt and yopt specify how the box should be drawn as\n"
15701 " described below. If ticks and/or subticks are to be drawn for a\n"
15702 " particular axis, the tick intervals and number of subintervals may be\n"
15703 " specified explicitly, or they may be defaulted by setting the\n"
15704 " appropriate arguments to zero.\n"
15705 "\n"
15706 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15707 "\n"
15708 "\n"
15709 " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15710 " and 29.\n"
15711 "\n"
15712 "\n"
15713 "\n"
15714 "SYNOPSIS:\n"
15715 "\n"
15716 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15717 "\n"
15718 "ARGUMENTS:\n"
15719 "\n"
15720 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15721 " options for the x axis. The string can include any combination of\n"
15722 " the following letters (upper or lower case) in any order: a: Draws\n"
15723 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15724 " (x=0).\n"
15725 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15726 " c: Draws top (X) or right (Y) edge of frame.\n"
15727 " d: Plot labels as date / time. Values are assumed to be\n"
15728 " seconds since the epoch (as used by gmtime).\n"
15729 " f: Always use fixed point numeric labels.\n"
15730 " g: Draws a grid at the major tick interval.\n"
15731 " h: Draws a grid at the minor tick interval.\n"
15732 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15733 " inwards.\n"
15734 " l: Labels axis logarithmically. This only affects the labels,\n"
15735 " not the data, and so it is necessary to compute the logarithms\n"
15736 " of data points before passing them to any of the drawing\n"
15737 " routines.\n"
15738 " m: Writes numeric labels at major tick intervals in the\n"
15739 " unconventional location (above box for X, right of box for Y).\n"
15740 " n: Writes numeric labels at major tick intervals in the\n"
15741 " conventional location (below box for X, left of box for Y).\n"
15742 " o: Use custom labelling function to generate axis label text.\n"
15743 " The custom labelling function can be defined with the\n"
15744 " plslabelfunc command.\n"
15745 " s: Enables subticks between major ticks, only valid if t is\n"
15746 " also specified.\n"
15747 " t: Draws major ticks.\n"
15748 " u: Exactly like \"b\" except don't draw edge line.\n"
15749 " w: Exactly like \"c\" except don't draw edge line.\n"
15750 " x: Exactly like \"t\" (including the side effect of the\n"
15751 " numerical labels for the major ticks) except exclude drawing\n"
15752 " the major and minor tick marks.\n"
15753 "\n"
15754 "\n"
15755 " xtick (PLFLT, input) : World coordinate interval between major\n"
15756 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15757 " generates a suitable tick interval.\n"
15758 "\n"
15759 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15760 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15761 " generates a suitable minor tick interval.\n"
15762 "\n"
15763 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15764 " options for the y axis. The string can include any combination of\n"
15765 " the letters defined above for xopt, and in addition may contain:\n"
15766 " v: Write numeric labels for the y axis parallel to the base of the\n"
15767 " graph, rather than parallel to the axis.\n"
15768 "\n"
15769 "\n"
15770 " ytick (PLFLT, input) : World coordinate interval between major\n"
15771 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15772 " generates a suitable tick interval.\n"
15773 "\n"
15774 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15775 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15776 " generates a suitable minor tick interval.\n"
15777 "\n"
15778 ""},
15779 { "plbox3", _wrap_plbox3, METH_VARARGS, "\n"
15780 "Draw a box with axes, etc, in 3-d\n"
15781 "\n"
15782 "DESCRIPTION:\n"
15783 "\n"
15784 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15785 " plot. For a more complete description of three-dimensional plotting\n"
15786 " see the PLplot documentation.\n"
15787 "\n"
15788 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15789 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15790 "\n"
15791 "\n"
15792 " This function is used in examples 8, 11, 18, and 21.\n"
15793 "\n"
15794 "\n"
15795 "\n"
15796 "SYNOPSIS:\n"
15797 "\n"
15798 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15799 "\n"
15800 "ARGUMENTS:\n"
15801 "\n"
15802 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15803 " options for the x axis. The string can include any combination of\n"
15804 " the following letters (upper or lower case) in any order: b: Draws\n"
15805 " axis at base, at height z=\n"
15806 " zmin where zmin is defined by call to plw3d. This character must be\n"
15807 " specified in order to use any of the other options.\n"
15808 " d: Plot labels as date / time. Values are assumed to be\n"
15809 " seconds since the epoch (as used by gmtime).\n"
15810 " f: Always use fixed point numeric labels.\n"
15811 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15812 " than upwards.\n"
15813 " l: Labels axis logarithmically. This only affects the labels,\n"
15814 " not the data, and so it is necessary to compute the logarithms\n"
15815 " of data points before passing them to any of the drawing\n"
15816 " routines.\n"
15817 " n: Writes numeric labels at major tick intervals.\n"
15818 " o: Use custom labelling function to generate axis label text.\n"
15819 " The custom labelling function can be defined with the\n"
15820 " plslabelfunc command.\n"
15821 " s: Enables subticks between major ticks, only valid if t is\n"
15822 " also specified.\n"
15823 " t: Draws major ticks.\n"
15824 " u: If this is specified, the text label for the axis is\n"
15825 " written under the axis.\n"
15826 "\n"
15827 "\n"
15828 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15829 " the text label for the x axis. It is only drawn if u is in the\n"
15830 " xopt string.\n"
15831 "\n"
15832 " xtick (PLFLT, input) : World coordinate interval between major\n"
15833 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15834 " generates a suitable tick interval.\n"
15835 "\n"
15836 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15837 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15838 " generates a suitable minor tick interval.\n"
15839 "\n"
15840 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15841 " options for the y axis. The string is interpreted in the same way\n"
15842 " as xopt.\n"
15843 "\n"
15844 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15845 " the text label for the y axis. It is only drawn if u is in the\n"
15846 " yopt string.\n"
15847 "\n"
15848 " ytick (PLFLT, input) : World coordinate interval between major\n"
15849 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15850 " generates a suitable tick interval.\n"
15851 "\n"
15852 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15853 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15854 " generates a suitable minor tick interval.\n"
15855 "\n"
15856 " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15857 " options for the z axis. The string can include any combination of\n"
15858 " the following letters (upper or lower case) in any order: b: Draws\n"
15859 " z axis to the left of the surface plot.\n"
15860 " c: Draws z axis to the right of the surface plot.\n"
15861 " d: Draws grid lines parallel to the x-y plane behind the\n"
15862 " figure. These lines are not drawn until after plot3d or\n"
15863 " plmesh are called because of the need for hidden line removal.\n"
15864 " e: Plot labels as date / time. Values are assumed to be\n"
15865 " seconds since the epoch (as used by gmtime). Note this\n"
15866 " suboption is interpreted the same as the d suboption for xopt\n"
15867 " and yopt, but it has to be identified as e for zopt since d\n"
15868 " has already been used for the different purpose above.\n"
15869 " f: Always use fixed point numeric labels.\n"
15870 " i: Inverts tick marks, so they are drawn away from the center.\n"
15871 " l: Labels axis logarithmically. This only affects the labels,\n"
15872 " not the data, and so it is necessary to compute the logarithms\n"
15873 " of data points before passing them to any of the drawing\n"
15874 " routines.\n"
15875 " m: Writes numeric labels at major tick intervals on the\n"
15876 " right-hand z axis.\n"
15877 " n: Writes numeric labels at major tick intervals on the\n"
15878 " left-hand z axis.\n"
15879 " o: Use custom labelling function to generate axis label text.\n"
15880 " The custom labelling function can be defined with the\n"
15881 " plslabelfunc command.\n"
15882 " s: Enables subticks between major ticks, only valid if t is\n"
15883 " also specified.\n"
15884 " t: Draws major ticks.\n"
15885 " u: If this is specified, the text label is written beside the\n"
15886 " left-hand axis.\n"
15887 " v: If this is specified, the text label is written beside the\n"
15888 " right-hand axis.\n"
15889 "\n"
15890 "\n"
15891 " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15892 " the text label for the z axis. It is only drawn if u or v are in\n"
15893 " the zopt string.\n"
15894 "\n"
15895 " ztick (PLFLT, input) : World coordinate interval between major\n"
15896 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15897 " generates a suitable tick interval.\n"
15898 "\n"
15899 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15900 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15901 " generates a suitable minor tick interval.\n"
15902 "\n"
15903 ""},
15904 { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, "\n"
15905 "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15906 "\n"
15907 "DESCRIPTION:\n"
15908 "\n"
15909 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15910 " from relative device coordinates, rx and ry.\n"
15911 "\n"
15912 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15913 "\n"
15914 "\n"
15915 " This function is used in example 31.\n"
15916 "\n"
15917 "\n"
15918 "\n"
15919 "SYNOPSIS:\n"
15920 "\n"
15921 "plcalc_world(rx, ry, wx, wy, window)\n"
15922 "\n"
15923 "ARGUMENTS:\n"
15924 "\n"
15925 " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15926 " the x coordinate.\n"
15927 "\n"
15928 " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15929 " the y coordinate.\n"
15930 "\n"
15931 " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15932 " coordinate corresponding to the relative device coordinates rx and\n"
15933 " ry.\n"
15934 "\n"
15935 " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15936 " coordinate corresponding to the relative device coordinates rx and\n"
15937 " ry.\n"
15938 "\n"
15939 " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15940 " defined window index that corresponds to the input relative device\n"
15941 " coordinates (and the returned world coordinates). To give some\n"
15942 " background on the window index, for each page the initial window\n"
15943 " index is set to zero, and each time plwind is called within the\n"
15944 " page, world and device coordinates are stored for the window and\n"
15945 " the window index is incremented. Thus, for a simple page layout\n"
15946 " with non-overlapping viewports and one window per viewport, window\n"
15947 " corresponds to the viewport index (in the order which the\n"
15948 " viewport/windows were created) of the only viewport/window\n"
15949 " corresponding to rx and ry. However, for more complicated layouts\n"
15950 " with potentially overlapping viewports and possibly more than one\n"
15951 " window (set of world coordinates) per viewport, window and the\n"
15952 " corresponding output world coordinates corresponds to the last\n"
15953 " window created that fulfills the criterion that the relative\n"
15954 " device coordinates are inside it. Finally, in all cases where the\n"
15955 " input relative device coordinates are not inside any\n"
15956 " viewport/window, then the returned value of the last defined\n"
15957 " window index is set to -1.\n"
15958 "\n"
15959 ""},
15960 { "plclear", _wrap_plclear, METH_NOARGS, "\n"
15961 "Clear current (sub)page\n"
15962 "\n"
15963 "DESCRIPTION:\n"
15964 "\n"
15965 " Clears the current page, effectively erasing everything that have been\n"
15966 " drawn. This command only works with interactive drivers; if the\n"
15967 " driver does not support this, the page is filled with the background\n"
15968 " color in use. If the current page is divided into subpages, only the\n"
15969 " current subpage is erased. The nth subpage can be selected with\n"
15970 " pladv(n).\n"
15971 "\n"
15972 " Redacted form: General: plclear()\n"
15973 "\n"
15974 "\n"
15975 " This function is not used in any examples.\n"
15976 "\n"
15977 "\n"
15978 "\n"
15979 "SYNOPSIS:\n"
15980 "\n"
15981 "plclear()\n"
15982 "\n"
15983 ""},
15984 { "plcol0", _wrap_plcol0, METH_O, "\n"
15985 "Set color, cmap0\n"
15986 "\n"
15987 "DESCRIPTION:\n"
15988 "\n"
15989 " Sets the color index for cmap0 (see the PLplot documentation).\n"
15990 "\n"
15991 " Redacted form: plcol0(icol0)\n"
15992 "\n"
15993 " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
15994 "\n"
15995 "\n"
15996 "\n"
15997 "SYNOPSIS:\n"
15998 "\n"
15999 "plcol0(icol0)\n"
16000 "\n"
16001 "ARGUMENTS:\n"
16002 "\n"
16003 " icol0 (PLINT, input) : Integer representing the color. The\n"
16004 " defaults at present are (these may change):\n"
16005 " 0 black (default background)\n"
16006 " 1 red (default foreground)\n"
16007 " 2 yellow\n"
16008 " 3 green\n"
16009 " 4 aquamarine\n"
16010 " 5 pink\n"
16011 " 6 wheat\n"
16012 " 7 grey\n"
16013 " 8 brown\n"
16014 " 9 blue\n"
16015 " 10 BlueViolet\n"
16016 " 11 cyan\n"
16017 " 12 turquoise\n"
16018 " 13 magenta\n"
16019 " 14 salmon\n"
16020 " 15 white\n"
16021 "\n"
16022 " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
16023 " change an individual color in the cmap0 color palette.\n"
16024 "\n"
16025 ""},
16026 { "plcol1", _wrap_plcol1, METH_O, "\n"
16027 "Set color, cmap1\n"
16028 "\n"
16029 "DESCRIPTION:\n"
16030 "\n"
16031 " Sets the color for cmap1 (see the PLplot documentation).\n"
16032 "\n"
16033 " Redacted form: plcol1(col1)\n"
16034 "\n"
16035 " This function is used in examples 12 and 21.\n"
16036 "\n"
16037 "\n"
16038 "\n"
16039 "SYNOPSIS:\n"
16040 "\n"
16041 "plcol1(col1)\n"
16042 "\n"
16043 "ARGUMENTS:\n"
16044 "\n"
16045 " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
16046 " is mapped to color using the continuous cmap1 palette which by\n"
16047 " default ranges from blue to the background color to red. The\n"
16048 " cmap1 palette can also be straightforwardly changed by the user\n"
16049 " with plscmap1 or plscmap1l.\n"
16050 "\n"
16051 ""},
16052 { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, "\n"
16053 "Configure the transformation between continuous and broken-down time for the current stream\n"
16054 "\n"
16055 "DESCRIPTION:\n"
16056 "\n"
16057 " Configure the transformation between continuous and broken-down time\n"
16058 " for the current stream. This transformation is used by both plbtime\n"
16059 " and plctime.\n"
16060 "\n"
16061 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
16062 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16063 "\n"
16064 "\n"
16065 " This function is used in example 29.\n"
16066 "\n"
16067 "\n"
16068 "\n"
16069 "SYNOPSIS:\n"
16070 "\n"
16071 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16072 "\n"
16073 "ARGUMENTS:\n"
16074 "\n"
16075 " scale (PLFLT, input) : The number of days per continuous time unit.\n"
16076 " As a special case, if\n"
16077 " scale is 0., then all other arguments are ignored, and the result (the\n"
16078 " default used by PLplot) is the equivalent of a call to\n"
16079 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
16080 " That is, for this special case broken-down time is calculated with\n"
16081 " the proleptic Gregorian calendar with no leap seconds inserted,\n"
16082 " and the continuous time is defined as the number of seconds since\n"
16083 " the Unix epoch of 1970-01-01T00:00:00Z.\n"
16084 "\n"
16085 " offset1 (PLFLT, input) : If\n"
16086 " ifbtime_offset is true, the parameters\n"
16087 " offset1 and\n"
16088 " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
16089 " (with units in days) specify the epoch of the continuous time\n"
16090 " relative to the MJD epoch corresponding to the Gregorian calendar\n"
16091 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
16092 " are used to specify the origin to allow users (by specifying\n"
16093 " offset1 as an integer that can be exactly represented by a\n"
16094 " floating-point variable and specifying\n"
16095 " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
16096 " the numerical errors of the continuous time representation.\n"
16097 "\n"
16098 " offset2 (PLFLT, input) : See documentation of\n"
16099 " offset1.\n"
16100 "\n"
16101 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
16102 " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
16103 " calendar is used for broken-down time rather than the proleptic\n"
16104 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
16105 " have been historically used to define UTC are inserted into the\n"
16106 " broken-down time. Other possibilities for additional control bits\n"
16107 " for ccontrol exist such as making the historical time corrections\n"
16108 " in the broken-down time corresponding to ET (ephemeris time) or\n"
16109 " making the (slightly non-constant) corrections from international\n"
16110 " atomic time (TAI) to what astronomers define as terrestrial time\n"
16111 " (TT). But those additional possibilities have not been\n"
16112 " implemented yet in the qsastime library (one of the PLplot utility\n"
16113 " libraries).\n"
16114 "\n"
16115 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
16116 " epoch of the continuous time scale is specified by the user. If\n"
16117 " ifbtime_offset is false, then\n"
16118 " offset1 and\n"
16119 " offset2 are used to specify the epoch, and the following broken-down\n"
16120 " time parameters are completely ignored. If\n"
16121 " ifbtime_offset is true, then\n"
16122 " offset1 and\n"
16123 " offset2 are completely ignored, and the following broken-down time\n"
16124 " parameters are used to specify the epoch.\n"
16125 "\n"
16126 " year (PLINT, input) : Year of epoch.\n"
16127 "\n"
16128 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
16129 " 11 (December).\n"
16130 "\n"
16131 " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
16132 "\n"
16133 " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
16134 "\n"
16135 " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
16136 "\n"
16137 " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
16138 "\n"
16139 ""},
16140 { "plcont", _wrap_plcont, METH_VARARGS, "\n"
16141 "Contour plot\n"
16142 "\n"
16143 "DESCRIPTION:\n"
16144 "\n"
16145 " Draws a contour plot of the data in f[\n"
16146 " nx][\n"
16147 " ny], using the nlevel contour levels specified by clevel. Only the\n"
16148 " region of the matrix from kx to lx and from ky to ly is plotted out\n"
16149 " where all these index ranges are interpreted as one-based for\n"
16150 " historical reasons. A transformation routine pointed to by pltr with\n"
16151 " a generic pointer pltr_data for additional data required by the\n"
16152 " transformation routine is used to map indices within the matrix to the\n"
16153 " world coordinates.\n"
16154 "\n"
16155 " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16156 " where (see above discussion) the pltr, pltr_data callback arguments\n"
16157 " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
16158 " vectors; or xg and yg matrices.\n"
16159 "\n"
16160 " This function is used in examples 9, 14, 16, and 22.\n"
16161 "\n"
16162 "\n"
16163 "\n"
16164 "SYNOPSIS:\n"
16165 "\n"
16166 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16167 "\n"
16168 "ARGUMENTS:\n"
16169 "\n"
16170 " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
16171 "\n"
16172 " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
16173 "\n"
16174 " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
16175 " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
16176 " zero-based for historical backwards-compatibility reasons.\n"
16177 "\n"
16178 " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
16179 " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
16180 " zero-based for historical backwards-compatibility reasons.\n"
16181 "\n"
16182 " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
16183 " which to draw contours.\n"
16184 "\n"
16185 " nlevel (PLINT, input) : Number of contour levels to draw.\n"
16186 "\n"
16187 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
16188 " defines the transformation between the zero-based indices of the\n"
16189 " matrix f and the world coordinates.For the C case, transformation\n"
16190 " functions are provided in the PLplot library: pltr0 for the\n"
16191 " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
16192 " respectively defined by vectors and matrices. In addition, C\n"
16193 " callback routines for the transformation can be supplied by the\n"
16194 " user such as the mypltr function in examples/c/x09c.c which\n"
16195 " provides a general linear transformation between index coordinates\n"
16196 " and world coordinates.For languages other than C you should\n"
16197 " consult the PLplot documentation for the details concerning how\n"
16198 " PLTRANSFORM_callback arguments are interfaced. However, in\n"
16199 " general, a particular pattern of callback-associated arguments\n"
16200 " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
16201 " yg matrices are respectively interfaced to a linear-transformation\n"
16202 " routine similar to the above mypltr function; pltr1; and pltr2.\n"
16203 " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
16204 " the PLplot documentation) support native language callbacks for\n"
16205 " handling index to world-coordinate transformations. Examples of\n"
16206 " these various approaches are given in examples/<language>x09*,\n"
16207 " examples/<language>x16*, examples/<language>x20*,\n"
16208 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
16209 " supported languages.\n"
16210 "\n"
16211 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
16212 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
16213 " that is externally supplied.\n"
16214 "\n"
16215 ""},
16216 { "plctime", _wrap_plctime, METH_VARARGS, "\n"
16217 "Calculate continuous time from broken-down time for the current stream\n"
16218 "\n"
16219 "DESCRIPTION:\n"
16220 "\n"
16221 " Calculate continuous time, ctime, from broken-down time for the\n"
16222 " current stream. The broken-down\n"
16223 " time is specified by the following parameters: year, month, day, hour,\n"
16224 " min, and sec. This function is the inverse of plbtime.\n"
16225 "\n"
16226 " The PLplot definition of broken-down time is a calendar time that\n"
16227 " completely ignores all time zone offsets, i.e., it is the user's\n"
16228 " responsibility to apply those offsets (if so desired) before using the\n"
16229 " PLplot time API. By default broken-down time is defined using the\n"
16230 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16231 " continuous time is defined as the number of seconds since the Unix\n"
16232 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16233 " broken-down and continuous time are possible, see plconfigtime which\n"
16234 " specifies that transformation for the current stream.\n"
16235 "\n"
16236 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16237 " ctime)\n"
16238 "\n"
16239 "\n"
16240 " This function is used in example 29.\n"
16241 "\n"
16242 "\n"
16243 "\n"
16244 "SYNOPSIS:\n"
16245 "\n"
16246 "plctime(year, month, day, hour, min, sec, ctime)\n"
16247 "\n"
16248 "ARGUMENTS:\n"
16249 "\n"
16250 " year (PLINT, input) : Input year.\n"
16251 "\n"
16252 " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16253 " (December).\n"
16254 "\n"
16255 " day (PLINT, input) : Input day in range from 1 to 31.\n"
16256 "\n"
16257 " hour (PLINT, input) : Input hour in range from 0 to 23\n"
16258 "\n"
16259 " min (PLINT, input) : Input minute in range from 0 to 59.\n"
16260 "\n"
16261 " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
16262 "\n"
16263 " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
16264 " time calculated from the broken-down time specified by the\n"
16265 " previous parameters.\n"
16266 "\n"
16267 ""},
16268 { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, "\n"
16269 "Copy state parameters from the reference stream to the current stream\n"
16270 "\n"
16271 "DESCRIPTION:\n"
16272 "\n"
16273 " Copies state parameters from the reference stream to the current\n"
16274 " stream. Tell driver interface to map device coordinates unless flags\n"
16275 " == 1.\n"
16276 "\n"
16277 " This function is used for making save files of selected plots (e.g.\n"
16278 " from the TK driver). After initializing, you can get a copy of the\n"
16279 " current plot to the specified device by switching to this stream and\n"
16280 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16281 " appropriate. The plot buffer must have previously been enabled (done\n"
16282 " automatically by some display drivers, such as X).\n"
16283 "\n"
16284 " Redacted form: plcpstrm(iplsr, flags)\n"
16285 "\n"
16286 " This function is used in example 1,20.\n"
16287 "\n"
16288 "\n"
16289 "\n"
16290 "SYNOPSIS:\n"
16291 "\n"
16292 "plcpstrm(iplsr, flags)\n"
16293 "\n"
16294 "ARGUMENTS:\n"
16295 "\n"
16296 " iplsr (PLINT, input) : Number of reference stream.\n"
16297 "\n"
16298 " flags (PLBOOL, input) : If flags is set to true the device\n"
16299 " coordinates are not copied from the reference to current stream.\n"
16300 "\n"
16301 ""},
16302 { "plend", _wrap_plend, METH_NOARGS, "\n"
16303 "End plotting session\n"
16304 "\n"
16305 "DESCRIPTION:\n"
16306 "\n"
16307 " Ends a plotting session, tidies up all the output files, switches\n"
16308 " interactive devices back into text mode and frees up any memory that\n"
16309 " was allocated. Must be called before end of program.\n"
16310 "\n"
16311 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16312 " wait state after a call to plend or other functions which trigger the\n"
16313 " end of a plot page. To avoid this, use the plspause function.\n"
16314 "\n"
16315 " Redacted form: plend()\n"
16316 "\n"
16317 " This function is used in all of the examples.\n"
16318 "\n"
16319 "\n"
16320 "\n"
16321 "SYNOPSIS:\n"
16322 "\n"
16323 "plend()\n"
16324 "\n"
16325 ""},
16326 { "plend1", _wrap_plend1, METH_NOARGS, "\n"
16327 "End plotting session for current stream\n"
16328 "\n"
16329 "DESCRIPTION:\n"
16330 "\n"
16331 " Ends a plotting session for the current output stream only. See\n"
16332 " plsstrm for more info.\n"
16333 "\n"
16334 " Redacted form: plend1()\n"
16335 "\n"
16336 " This function is used in examples 1 and 20.\n"
16337 "\n"
16338 "\n"
16339 "\n"
16340 "SYNOPSIS:\n"
16341 "\n"
16342 "plend1()\n"
16343 "\n"
16344 ""},
16345 { "plenv", _wrap_plenv, METH_VARARGS, "\n"
16346 "Set up standard window and draw box\n"
16347 "\n"
16348 "DESCRIPTION:\n"
16349 "\n"
16350 " Sets up plotter environment for simple graphs by calling pladv and\n"
16351 " setting up viewport and window to sensible default values. plenv\n"
16352 " leaves a standard margin (left-hand margin of eight character heights,\n"
16353 " and a margin around the other three sides of five character heights)\n"
16354 " around most graphs for axis labels and a title. When these defaults\n"
16355 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16356 " plvasp for setting up the viewport, plwind for defining the window,\n"
16357 " and plbox for drawing the box.\n"
16358 "\n"
16359 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16360 "\n"
16361 " This function is used in example 1,3,9,13,14,19-22,29.\n"
16362 "\n"
16363 "\n"
16364 "\n"
16365 "SYNOPSIS:\n"
16366 "\n"
16367 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16368 "\n"
16369 "ARGUMENTS:\n"
16370 "\n"
16371 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16372 " world coordinates).\n"
16373 "\n"
16374 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16375 " world coordinates).\n"
16376 "\n"
16377 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16378 " coordinates).\n"
16379 "\n"
16380 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16381 " coordinates).\n"
16382 "\n"
16383 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16384 " scales will not be set, the user must set up the scale before\n"
16385 " calling plenv using plsvpa, plvasp or other.\n"
16386 " 0: the x and y axes are scaled independently to use as much of\n"
16387 " the screen as possible.\n"
16388 " 1: the scales of the x and y axes are made equal.\n"
16389 " 2: the axis of the x and y axes are made equal, and the plot\n"
16390 " box will be square.\n"
16391 "\n"
16392 "\n"
16393 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16394 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16395 " -1: draw box only.\n"
16396 " 0: draw box, ticks, and numeric tick labels.\n"
16397 " 1: also draw coordinate axes at x=0 and y=0.\n"
16398 " 2: also draw a grid at major tick positions in both\n"
16399 " coordinates.\n"
16400 " 3: also draw a grid at minor tick positions in both\n"
16401 " coordinates.\n"
16402 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16403 " have to be converted to logarithms separately.)\n"
16404 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16405 " have to be converted to logarithms separately.)\n"
16406 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16407 " have to be converted to logarithms separately.)\n"
16408 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16409 " have to be converted to logarithms separately.)\n"
16410 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16411 " have to be converted to logarithms separately.)\n"
16412 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16413 " have to be converted to logarithms separately.)\n"
16414 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16415 " have to be converted to logarithms separately.)\n"
16416 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16417 " have to be converted to logarithms separately.)\n"
16418 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16419 " and y data have to be converted to logarithms separately.)\n"
16420 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16421 " and y data have to be converted to logarithms separately.)\n"
16422 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16423 " and y data have to be converted to logarithms separately.)\n"
16424 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16425 " and y data have to be converted to logarithms separately.)\n"
16426 " 40: same as 0 except date / time x labels.\n"
16427 " 41: same as 1 except date / time x labels.\n"
16428 " 42: same as 2 except date / time x labels.\n"
16429 " 43: same as 3 except date / time x labels.\n"
16430 " 50: same as 0 except date / time y labels.\n"
16431 " 51: same as 1 except date / time y labels.\n"
16432 " 52: same as 2 except date / time y labels.\n"
16433 " 53: same as 3 except date / time y labels.\n"
16434 " 60: same as 0 except date / time x and y labels.\n"
16435 " 61: same as 1 except date / time x and y labels.\n"
16436 " 62: same as 2 except date / time x and y labels.\n"
16437 " 63: same as 3 except date / time x and y labels.\n"
16438 " 70: same as 0 except custom x and y labels.\n"
16439 " 71: same as 1 except custom x and y labels.\n"
16440 " 72: same as 2 except custom x and y labels.\n"
16441 " 73: same as 3 except custom x and y labels.\n"
16442 "\n"
16443 ""},
16444 { "plenv0", _wrap_plenv0, METH_VARARGS, "\n"
16445 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16446 "\n"
16447 "DESCRIPTION:\n"
16448 "\n"
16449 " Sets up plotter environment for simple graphs by calling pladv and\n"
16450 " setting up viewport and window to sensible default values. plenv0\n"
16451 " leaves a standard margin (left-hand margin of eight character heights,\n"
16452 " and a margin around the other three sides of five character heights)\n"
16453 " around most graphs for axis labels and a title. When these defaults\n"
16454 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16455 " plvasp for setting up the viewport, plwind for defining the window,\n"
16456 " and plbox for drawing the box.\n"
16457 "\n"
16458 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16459 "\n"
16460 " This function is used in example 21.\n"
16461 "\n"
16462 "\n"
16463 "\n"
16464 "SYNOPSIS:\n"
16465 "\n"
16466 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16467 "\n"
16468 "ARGUMENTS:\n"
16469 "\n"
16470 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16471 " world coordinates).\n"
16472 "\n"
16473 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16474 " world coordinates).\n"
16475 "\n"
16476 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16477 " coordinates).\n"
16478 "\n"
16479 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16480 " coordinates).\n"
16481 "\n"
16482 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16483 " scales will not be set, the user must set up the scale before\n"
16484 " calling plenv0 using plsvpa, plvasp or other.\n"
16485 " 0: the x and y axes are scaled independently to use as much of\n"
16486 " the screen as possible.\n"
16487 " 1: the scales of the x and y axes are made equal.\n"
16488 " 2: the axis of the x and y axes are made equal, and the plot\n"
16489 " box will be square.\n"
16490 "\n"
16491 "\n"
16492 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16493 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16494 " -1: draw box only.\n"
16495 " 0: draw box, ticks, and numeric tick labels.\n"
16496 " 1: also draw coordinate axes at x=0 and y=0.\n"
16497 " 2: also draw a grid at major tick positions in both\n"
16498 " coordinates.\n"
16499 " 3: also draw a grid at minor tick positions in both\n"
16500 " coordinates.\n"
16501 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16502 " have to be converted to logarithms separately.)\n"
16503 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16504 " have to be converted to logarithms separately.)\n"
16505 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16506 " have to be converted to logarithms separately.)\n"
16507 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16508 " have to be converted to logarithms separately.)\n"
16509 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16510 " have to be converted to logarithms separately.)\n"
16511 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16512 " have to be converted to logarithms separately.)\n"
16513 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16514 " have to be converted to logarithms separately.)\n"
16515 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16516 " have to be converted to logarithms separately.)\n"
16517 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16518 " and y data have to be converted to logarithms separately.)\n"
16519 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16520 " and y data have to be converted to logarithms separately.)\n"
16521 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16522 " and y data have to be converted to logarithms separately.)\n"
16523 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16524 " and y data have to be converted to logarithms separately.)\n"
16525 " 40: same as 0 except date / time x labels.\n"
16526 " 41: same as 1 except date / time x labels.\n"
16527 " 42: same as 2 except date / time x labels.\n"
16528 " 43: same as 3 except date / time x labels.\n"
16529 " 50: same as 0 except date / time y labels.\n"
16530 " 51: same as 1 except date / time y labels.\n"
16531 " 52: same as 2 except date / time y labels.\n"
16532 " 53: same as 3 except date / time y labels.\n"
16533 " 60: same as 0 except date / time x and y labels.\n"
16534 " 61: same as 1 except date / time x and y labels.\n"
16535 " 62: same as 2 except date / time x and y labels.\n"
16536 " 63: same as 3 except date / time x and y labels.\n"
16537 " 70: same as 0 except custom x and y labels.\n"
16538 " 71: same as 1 except custom x and y labels.\n"
16539 " 72: same as 2 except custom x and y labels.\n"
16540 " 73: same as 3 except custom x and y labels.\n"
16541 "\n"
16542 ""},
16543 { "pleop", _wrap_pleop, METH_NOARGS, "\n"
16544 "Eject current page\n"
16545 "\n"
16546 "DESCRIPTION:\n"
16547 "\n"
16548 " Clears the graphics screen of an interactive device, or ejects a page\n"
16549 " on a plotter. See plbop for more information.\n"
16550 "\n"
16551 " Redacted form: pleop()\n"
16552 "\n"
16553 " This function is used in example 2,14.\n"
16554 "\n"
16555 "\n"
16556 "\n"
16557 "SYNOPSIS:\n"
16558 "\n"
16559 "pleop()\n"
16560 "\n"
16561 ""},
16562 { "plerrx", _wrap_plerrx, METH_VARARGS, "\n"
16563 "Draw error bars in x direction\n"
16564 "\n"
16565 "DESCRIPTION:\n"
16566 "\n"
16567 " Draws a set of n error bars in x direction, the i'th error bar\n"
16568 " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16569 " of the error bars are of length equal to the minor tick length\n"
16570 " (settable using plsmin).\n"
16571 "\n"
16572 " Redacted form: General: plerrx(xmin, ymax, y)\n"
16573 "\n"
16574 "\n"
16575 " This function is used in example 29.\n"
16576 "\n"
16577 "\n"
16578 "\n"
16579 "SYNOPSIS:\n"
16580 "\n"
16581 "plerrx(n, xmin, xmax, y)\n"
16582 "\n"
16583 "ARGUMENTS:\n"
16584 "\n"
16585 " n (PLINT, input) : Number of error bars to draw.\n"
16586 "\n"
16587 " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16588 " of the left-hand endpoints of the error bars.\n"
16589 "\n"
16590 " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16591 " of the right-hand endpoints of the error bars.\n"
16592 "\n"
16593 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16594 " the error bars.\n"
16595 "\n"
16596 ""},
16597 { "plerry", _wrap_plerry, METH_VARARGS, "\n"
16598 "Draw error bars in the y direction\n"
16599 "\n"
16600 "DESCRIPTION:\n"
16601 "\n"
16602 " Draws a set of n error bars in the y direction, the i'th error bar\n"
16603 " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16604 " of the error bars are of length equal to the minor tick length\n"
16605 " (settable using plsmin).\n"
16606 "\n"
16607 " Redacted form: General: plerry(x, ymin, ymax)\n"
16608 "\n"
16609 "\n"
16610 " This function is used in example 29.\n"
16611 "\n"
16612 "\n"
16613 "\n"
16614 "SYNOPSIS:\n"
16615 "\n"
16616 "plerry(n, x, ymin, ymax)\n"
16617 "\n"
16618 "ARGUMENTS:\n"
16619 "\n"
16620 " n (PLINT, input) : Number of error bars to draw.\n"
16621 "\n"
16622 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16623 " the error bars.\n"
16624 "\n"
16625 " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16626 " of the lower endpoints of the error bars.\n"
16627 "\n"
16628 " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16629 " of the upper endpoints of the error bars.\n"
16630 "\n"
16631 ""},
16632 { "plfamadv", _wrap_plfamadv, METH_NOARGS, "\n"
16633 "Advance to the next family file on the next new page\n"
16634 "\n"
16635 "DESCRIPTION:\n"
16636 "\n"
16637 " Advance to the next family file on the next new page.\n"
16638 "\n"
16639 " Redacted form: plfamadv()\n"
16640 "\n"
16641 " This function is not used in any examples.\n"
16642 "\n"
16643 "\n"
16644 "\n"
16645 "SYNOPSIS:\n"
16646 "\n"
16647 "plfamadv()\n"
16648 "\n"
16649 ""},
16650 { "plfill", _wrap_plfill, METH_VARARGS, "\n"
16651 "Draw filled polygon\n"
16652 "\n"
16653 "DESCRIPTION:\n"
16654 "\n"
16655 " Fills the polygon defined by the n points (\n"
16656 " x[i],\n"
16657 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16658 " style is a solid fill. The routine will automatically close the\n"
16659 " polygon between the last and first vertices. If multiple closed\n"
16660 " polygons are passed in x and y then plfill will fill in between them.\n"
16661 "\n"
16662 " Redacted form: plfill(x,y)\n"
16663 "\n"
16664 " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16665 "\n"
16666 "\n"
16667 "\n"
16668 "SYNOPSIS:\n"
16669 "\n"
16670 "plfill(n, x, y)\n"
16671 "\n"
16672 "ARGUMENTS:\n"
16673 "\n"
16674 " n (PLINT, input) : Number of vertices in polygon.\n"
16675 "\n"
16676 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16677 " vertices.\n"
16678 "\n"
16679 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16680 " vertices.\n"
16681 "\n"
16682 ""},
16683 { "plfill3", _wrap_plfill3, METH_VARARGS, "\n"
16684 "Draw filled polygon in 3D\n"
16685 "\n"
16686 "DESCRIPTION:\n"
16687 "\n"
16688 " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16689 " vectors using the pattern defined by plpsty or plpat. The routine\n"
16690 " will automatically close the polygon between the last and first\n"
16691 " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16692 " plfill3 will fill in between them.\n"
16693 "\n"
16694 " Redacted form: General: plfill3(x, y, z)\n"
16695 "\n"
16696 "\n"
16697 " This function is used in example 15.\n"
16698 "\n"
16699 "\n"
16700 "\n"
16701 "SYNOPSIS:\n"
16702 "\n"
16703 "plfill3(n, x, y, z)\n"
16704 "\n"
16705 "ARGUMENTS:\n"
16706 "\n"
16707 " n (PLINT, input) : Number of vertices in polygon.\n"
16708 "\n"
16709 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16710 " vertices.\n"
16711 "\n"
16712 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16713 " vertices.\n"
16714 "\n"
16715 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16716 " vertices.\n"
16717 "\n"
16718 ""},
16719 { "plgradient", _wrap_plgradient, METH_VARARGS, "\n"
16720 "Draw linear gradient inside polygon\n"
16721 "\n"
16722 "DESCRIPTION:\n"
16723 "\n"
16724 " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16725 " points (\n"
16726 " x[i],\n"
16727 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16728 " polygon coordinates and the gradient angle are all expressed in world\n"
16729 " coordinates. The angle from the x axis for both the rotated\n"
16730 " coordinate system and the gradient vector is specified by angle. The\n"
16731 " magnitude of the gradient vector is the difference between the maximum\n"
16732 " and minimum values of x for the vertices in the rotated coordinate\n"
16733 " system. The origin of the gradient vector can be interpreted as being\n"
16734 " anywhere on the line corresponding to the minimum x value for the\n"
16735 " vertices in the rotated coordinate system. The distance along the\n"
16736 " gradient vector is linearly transformed to the independent variable of\n"
16737 " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16738 " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16739 " color corresponding to the independent variable of cmap1. For more\n"
16740 " information about cmap1 (see the PLplot documentation).\n"
16741 "\n"
16742 " Redacted form: plgradient(x,y,angle)\n"
16743 "\n"
16744 " This function is used in examples 25 and 30.\n"
16745 "\n"
16746 "\n"
16747 "\n"
16748 "SYNOPSIS:\n"
16749 "\n"
16750 "plgradient(n, x, y, angle)\n"
16751 "\n"
16752 "ARGUMENTS:\n"
16753 "\n"
16754 " n (PLINT, input) : Number of vertices in polygon.\n"
16755 "\n"
16756 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16757 " vertices.\n"
16758 "\n"
16759 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16760 " vertices.\n"
16761 "\n"
16762 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16763 " axis.\n"
16764 "\n"
16765 ""},
16766 { "plflush", _wrap_plflush, METH_NOARGS, "\n"
16767 "Flushes the output stream\n"
16768 "\n"
16769 "DESCRIPTION:\n"
16770 "\n"
16771 " Flushes the output stream. Use sparingly, if at all.\n"
16772 "\n"
16773 " Redacted form: plflush()\n"
16774 "\n"
16775 " This function is used in examples 1 and 14.\n"
16776 "\n"
16777 "\n"
16778 "\n"
16779 "SYNOPSIS:\n"
16780 "\n"
16781 "plflush()\n"
16782 "\n"
16783 ""},
16784 { "plfont", _wrap_plfont, METH_O, "\n"
16785 "Set font\n"
16786 "\n"
16787 "DESCRIPTION:\n"
16788 "\n"
16789 " Sets the font used for subsequent text and symbols. For devices that\n"
16790 " still use Hershey fonts this routine has no effect unless the Hershey\n"
16791 " fonts with extended character set are loaded (see plfontld). For\n"
16792 " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16793 " this routine calls the plsfci routine with argument set up\n"
16794 " appropriately for the various cases below. However, this method of\n"
16795 " specifying the font for unicode-aware devices is deprecated, and the\n"
16796 " much more flexible method of calling plsfont directly is recommended\n"
16797 " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16798 "\n"
16799 " Redacted form: plfont(ifont)\n"
16800 "\n"
16801 " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16802 "\n"
16803 "\n"
16804 "\n"
16805 "SYNOPSIS:\n"
16806 "\n"
16807 "plfont(ifont)\n"
16808 "\n"
16809 "ARGUMENTS:\n"
16810 "\n"
16811 " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16812 " (simplest and fastest)\n"
16813 " 2: Serif font\n"
16814 " 3: Italic font\n"
16815 " 4: Script font\n"
16816 "\n"
16817 ""},
16818 { "plfontld", _wrap_plfontld, METH_O, "\n"
16819 "Load Hershey fonts\n"
16820 "\n"
16821 "DESCRIPTION:\n"
16822 "\n"
16823 " Loads the Hershey fonts used for text and symbols. This routine may\n"
16824 " be called before or after initializing PLplot. If not explicitly\n"
16825 " called before PLplot initialization, then by default that\n"
16826 " initialization loads Hershey fonts with the extended character set.\n"
16827 " This routine only has a practical effect for devices that still use\n"
16828 " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16829 " system fonts instead of Hershey fonts).\n"
16830 "\n"
16831 " Redacted form: plfontld(fnt)\n"
16832 "\n"
16833 " This function is used in examples 1 and 7.\n"
16834 "\n"
16835 "\n"
16836 "\n"
16837 "SYNOPSIS:\n"
16838 "\n"
16839 "plfontld(fnt)\n"
16840 "\n"
16841 "ARGUMENTS:\n"
16842 "\n"
16843 " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16844 " A zero value specifies Hershey fonts with the standard character\n"
16845 " set and a non-zero value (the default assumed if plfontld is never\n"
16846 " called) specifies Hershey fonts with the extended character set.\n"
16847 "\n"
16848 ""},
16849 { "plgchr", _wrap_plgchr, METH_NOARGS, "\n"
16850 "Get character default height and current (scaled) height\n"
16851 "\n"
16852 "DESCRIPTION:\n"
16853 "\n"
16854 " Get character default height and current (scaled) height.\n"
16855 "\n"
16856 " Redacted form: plgchr(p_def, p_ht)\n"
16857 "\n"
16858 " This function is used in example 23.\n"
16859 "\n"
16860 "\n"
16861 "\n"
16862 "SYNOPSIS:\n"
16863 "\n"
16864 "plgchr(p_def, p_ht)\n"
16865 "\n"
16866 "ARGUMENTS:\n"
16867 "\n"
16868 " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16869 " character height (mm).\n"
16870 "\n"
16871 " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16872 " character height (mm).\n"
16873 "\n"
16874 ""},
16875 { "plgcol0", _wrap_plgcol0, METH_O, "\n"
16876 "Returns 8-bit RGB values for given color index from cmap0\n"
16877 "\n"
16878 "DESCRIPTION:\n"
16879 "\n"
16880 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16881 " PLplot documentation). Values are negative if an invalid color id is\n"
16882 " given.\n"
16883 "\n"
16884 " Redacted form: plgcol0(icol0, r, g, b)\n"
16885 "\n"
16886 " This function is used in example 2.\n"
16887 "\n"
16888 "\n"
16889 "\n"
16890 "SYNOPSIS:\n"
16891 "\n"
16892 "plgcol0(icol0, r, g, b)\n"
16893 "\n"
16894 "ARGUMENTS:\n"
16895 "\n"
16896 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16897 "\n"
16898 " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16899 " value.\n"
16900 "\n"
16901 " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16902 " value.\n"
16903 "\n"
16904 " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16905 " value.\n"
16906 "\n"
16907 ""},
16908 { "plgcol0a", _wrap_plgcol0a, METH_O, "\n"
16909 "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16910 "\n"
16911 "DESCRIPTION:\n"
16912 "\n"
16913 " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16914 " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16915 " Values are negative if an invalid color id is given.\n"
16916 "\n"
16917 " Redacted form: plgcola(r, g, b)\n"
16918 "\n"
16919 " This function is used in example 30.\n"
16920 "\n"
16921 "\n"
16922 "\n"
16923 "SYNOPSIS:\n"
16924 "\n"
16925 "plgcol0a(icol0, r, g, b, alpha)\n"
16926 "\n"
16927 "ARGUMENTS:\n"
16928 "\n"
16929 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16930 "\n"
16931 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16932 " in the range from 0 to 255.\n"
16933 "\n"
16934 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16935 " in the range from 0 to 255.\n"
16936 "\n"
16937 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16938 " in the range from 0 to 255.\n"
16939 "\n"
16940 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16941 " transparency in the range from (0.0-1.0).\n"
16942 "\n"
16943 ""},
16944 { "plgcolbg", _wrap_plgcolbg, METH_NOARGS, "\n"
16945 "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16946 "\n"
16947 "DESCRIPTION:\n"
16948 "\n"
16949 " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16950 "\n"
16951 " Redacted form: plgcolbg(r, g, b)\n"
16952 "\n"
16953 " This function is used in example 31.\n"
16954 "\n"
16955 "\n"
16956 "\n"
16957 "SYNOPSIS:\n"
16958 "\n"
16959 "plgcolbg(r, g, b)\n"
16960 "\n"
16961 "ARGUMENTS:\n"
16962 "\n"
16963 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16964 " in the range from 0 to 255.\n"
16965 "\n"
16966 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16967 " in the range from 0 to 255.\n"
16968 "\n"
16969 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16970 " in the range from 0 to 255.\n"
16971 "\n"
16972 ""},
16973 { "plgcolbga", _wrap_plgcolbga, METH_NOARGS, "\n"
16974 "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
16975 "\n"
16976 "DESCRIPTION:\n"
16977 "\n"
16978 " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
16979 " alpha transparency value.\n"
16980 "\n"
16981 " This function is used in example 31.\n"
16982 "\n"
16983 "\n"
16984 "\n"
16985 "SYNOPSIS:\n"
16986 "\n"
16987 "plgcolbga(r, g, b, alpha)\n"
16988 "\n"
16989 "ARGUMENTS:\n"
16990 "\n"
16991 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16992 " in the range from 0 to 255.\n"
16993 "\n"
16994 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16995 " in the range from 0 to 255.\n"
16996 "\n"
16997 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16998 " in the range from 0 to 255.\n"
16999 "\n"
17000 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
17001 " transparency in the range (0.0-1.0).\n"
17002 "\n"
17003 ""},
17004 { "plgcompression", _wrap_plgcompression, METH_NOARGS, "\n"
17005 "Get the current device-compression setting\n"
17006 "\n"
17007 "DESCRIPTION:\n"
17008 "\n"
17009 " Get the current device-compression setting. This parameter is only\n"
17010 " used for drivers that provide compression.\n"
17011 "\n"
17012 " Redacted form: plgcompression(compression)\n"
17013 "\n"
17014 " This function is used in example 31.\n"
17015 "\n"
17016 "\n"
17017 "\n"
17018 "SYNOPSIS:\n"
17019 "\n"
17020 "plgcompression(compression)\n"
17021 "\n"
17022 "ARGUMENTS:\n"
17023 "\n"
17024 " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
17025 " compression setting for the current device.\n"
17026 "\n"
17027 ""},
17028 { "plgdev", _wrap_plgdev, METH_NOARGS, "\n"
17029 "Get the current device (keyword) name\n"
17030 "\n"
17031 "DESCRIPTION:\n"
17032 "\n"
17033 " Get the current device (keyword) name. Note: you must have allocated\n"
17034 " space for this (80 characters is safe).\n"
17035 "\n"
17036 " Redacted form: plgdev(p_dev)\n"
17037 "\n"
17038 " This function is used in example 14.\n"
17039 "\n"
17040 "\n"
17041 "\n"
17042 "SYNOPSIS:\n"
17043 "\n"
17044 "plgdev(p_dev)\n"
17045 "\n"
17046 "ARGUMENTS:\n"
17047 "\n"
17048 " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17049 " (with preallocated length of 80 characters or more) containing the\n"
17050 " device (keyword) name.\n"
17051 "\n"
17052 ""},
17053 { "plgdidev", _wrap_plgdidev, METH_NOARGS, "\n"
17054 "Get parameters that define current device-space window\n"
17055 "\n"
17056 "DESCRIPTION:\n"
17057 "\n"
17058 " Get relative margin width, aspect ratio, and relative justification\n"
17059 " that define current device-space window. If plsdidev has not been\n"
17060 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
17061 " p_jy will all be 0.\n"
17062 "\n"
17063 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17064 "\n"
17065 " This function is used in example 31.\n"
17066 "\n"
17067 "\n"
17068 "\n"
17069 "SYNOPSIS:\n"
17070 "\n"
17071 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17072 "\n"
17073 "ARGUMENTS:\n"
17074 "\n"
17075 " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17076 " margin width.\n"
17077 "\n"
17078 " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
17079 " ratio.\n"
17080 "\n"
17081 " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17082 " justification in x.\n"
17083 "\n"
17084 " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17085 " justification in y.\n"
17086 "\n"
17087 ""},
17088 { "plgdiori", _wrap_plgdiori, METH_NOARGS, "\n"
17089 "Get plot orientation\n"
17090 "\n"
17091 "DESCRIPTION:\n"
17092 "\n"
17093 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
17094 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
17095 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
17096 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
17097 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
17098 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
17099 " not been called the default value pointed to by p_rot will be 0.\n"
17100 "\n"
17101 " Redacted form: plgdiori(p_rot)\n"
17102 "\n"
17103 " This function is not used in any examples.\n"
17104 "\n"
17105 "\n"
17106 "\n"
17107 "SYNOPSIS:\n"
17108 "\n"
17109 "plgdiori(p_rot)\n"
17110 "\n"
17111 "ARGUMENTS:\n"
17112 "\n"
17113 " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
17114 " parameter.\n"
17115 "\n"
17116 ""},
17117 { "plgdiplt", _wrap_plgdiplt, METH_NOARGS, "\n"
17118 "Get parameters that define current plot-space window\n"
17119 "\n"
17120 "DESCRIPTION:\n"
17121 "\n"
17122 " Get relative minima and maxima that define current plot-space window.\n"
17123 " If plsdiplt has not been called the default values pointed to by\n"
17124 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
17125 "\n"
17126 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17127 "\n"
17128 " This function is used in example 31.\n"
17129 "\n"
17130 "\n"
17131 "\n"
17132 "SYNOPSIS:\n"
17133 "\n"
17134 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17135 "\n"
17136 "ARGUMENTS:\n"
17137 "\n"
17138 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17139 " minimum in x.\n"
17140 "\n"
17141 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17142 " minimum in y.\n"
17143 "\n"
17144 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17145 " maximum in x.\n"
17146 "\n"
17147 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17148 " maximum in y.\n"
17149 "\n"
17150 ""},
17151 { "plgfam", _wrap_plgfam, METH_NOARGS, "\n"
17152 "Get family file parameters\n"
17153 "\n"
17154 "DESCRIPTION:\n"
17155 "\n"
17156 " Gets information about current family file, if familying is enabled.\n"
17157 " See the PLplot documentation for more information.\n"
17158 "\n"
17159 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
17160 "\n"
17161 " This function is used in examples 14 and 31.\n"
17162 "\n"
17163 "\n"
17164 "\n"
17165 "SYNOPSIS:\n"
17166 "\n"
17167 "plgfam(p_fam, p_num, p_bmax)\n"
17168 "\n"
17169 "ARGUMENTS:\n"
17170 "\n"
17171 " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17172 " family flag value. If nonzero, familying is enabled for the\n"
17173 " current device.\n"
17174 "\n"
17175 " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17176 " family file number.\n"
17177 "\n"
17178 " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17179 " file size (in bytes) for a family file.\n"
17180 "\n"
17181 ""},
17182 { "plgfci", _wrap_plgfci, METH_NOARGS, "\n"
17183 "Get FCI (font characterization integer)\n"
17184 "\n"
17185 "DESCRIPTION:\n"
17186 "\n"
17187 " Gets information about the current font using the FCI approach. See\n"
17188 " the PLplot documentation for more information.\n"
17189 "\n"
17190 " Redacted form: plgfci(p_fci)\n"
17191 "\n"
17192 " This function is used in example 23.\n"
17193 "\n"
17194 "\n"
17195 "\n"
17196 "SYNOPSIS:\n"
17197 "\n"
17198 "plgfci(p_fci)\n"
17199 "\n"
17200 "ARGUMENTS:\n"
17201 "\n"
17202 " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
17203 " FCI value.\n"
17204 "\n"
17205 ""},
17206 { "plgfnam", _wrap_plgfnam, METH_NOARGS, "\n"
17207 "Get output file name\n"
17208 "\n"
17209 "DESCRIPTION:\n"
17210 "\n"
17211 " Gets the current output file name, if applicable.\n"
17212 "\n"
17213 " Redacted form: plgfnam(fnam)\n"
17214 "\n"
17215 " This function is used in example 31.\n"
17216 "\n"
17217 "\n"
17218 "\n"
17219 "SYNOPSIS:\n"
17220 "\n"
17221 "plgfnam(fnam)\n"
17222 "\n"
17223 "ARGUMENTS:\n"
17224 "\n"
17225 " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17226 " (with preallocated length of 80 characters or more) containing the\n"
17227 " file name.\n"
17228 "\n"
17229 ""},
17230 { "plgfont", _wrap_plgfont, METH_NOARGS, "\n"
17231 "Get family, style and weight of the current font\n"
17232 "\n"
17233 "DESCRIPTION:\n"
17234 "\n"
17235 " Gets information about current font. See the PLplot documentation for\n"
17236 " more information on font selection.\n"
17237 "\n"
17238 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17239 "\n"
17240 " This function is used in example 23.\n"
17241 "\n"
17242 "\n"
17243 "\n"
17244 "SYNOPSIS:\n"
17245 "\n"
17246 "plgfont(p_family, p_style, p_weight)\n"
17247 "\n"
17248 "ARGUMENTS:\n"
17249 "\n"
17250 " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17251 " font family. The available values are given by the PL_FCI_*\n"
17252 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17253 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17254 " p_family is NULL then the font family is not returned.\n"
17255 "\n"
17256 " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17257 " font style. The available values are given by the PL_FCI_*\n"
17258 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17259 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
17260 " style is not returned.\n"
17261 "\n"
17262 " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17263 " font weight. The available values are given by the PL_FCI_*\n"
17264 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17265 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17266 " returned.\n"
17267 "\n"
17268 ""},
17269 { "plglevel", _wrap_plglevel, METH_NOARGS, "\n"
17270 "Get the (current) run level\n"
17271 "\n"
17272 "DESCRIPTION:\n"
17273 "\n"
17274 " Get the (current) run level. Valid settings are: 0, uninitialized\n"
17275 " 1, initialized\n"
17276 " 2, viewport defined\n"
17277 " 3, world coordinates defined\n"
17278 "\n"
17279 "\n"
17280 " Redacted form: plglevel(p_level)\n"
17281 "\n"
17282 " This function is used in example 31.\n"
17283 "\n"
17284 "\n"
17285 "\n"
17286 "SYNOPSIS:\n"
17287 "\n"
17288 "plglevel(p_level)\n"
17289 "\n"
17290 "ARGUMENTS:\n"
17291 "\n"
17292 " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
17293 " level.\n"
17294 "\n"
17295 ""},
17296 { "plgpage", _wrap_plgpage, METH_NOARGS, "\n"
17297 "Get page parameters\n"
17298 "\n"
17299 "DESCRIPTION:\n"
17300 "\n"
17301 " Gets the current page configuration. The length and offset values are\n"
17302 " expressed in units that are specific to the current driver. For\n"
17303 " instance: screen drivers will usually interpret them as number of\n"
17304 " pixels, whereas printer drivers will usually use mm.\n"
17305 "\n"
17306 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17307 "\n"
17308 " This function is used in examples 14 and 31.\n"
17309 "\n"
17310 "\n"
17311 "\n"
17312 "SYNOPSIS:\n"
17313 "\n"
17314 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17315 "\n"
17316 "ARGUMENTS:\n"
17317 "\n"
17318 " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17319 " pixels/inch (DPI) in x.\n"
17320 "\n"
17321 " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17322 " pixels/inch (DPI) in y.\n"
17323 "\n"
17324 " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17325 " length.\n"
17326 "\n"
17327 " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17328 " length.\n"
17329 "\n"
17330 " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17331 " offset.\n"
17332 "\n"
17333 " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17334 " offset.\n"
17335 "\n"
17336 ""},
17337 { "plgra", _wrap_plgra, METH_NOARGS, "\n"
17338 "Switch to graphics screen\n"
17339 "\n"
17340 "DESCRIPTION:\n"
17341 "\n"
17342 " Sets an interactive device to graphics mode, used in conjunction with\n"
17343 " pltext to allow graphics and text to be interspersed. On a device\n"
17344 " which supports separate text and graphics windows, this command causes\n"
17345 " control to be switched to the graphics window. If already in graphics\n"
17346 " mode, this command is ignored. It is also ignored on devices which\n"
17347 " only support a single window or use a different method for shifting\n"
17348 " focus. See also pltext.\n"
17349 "\n"
17350 " Redacted form: plgra()\n"
17351 "\n"
17352 " This function is used in example 1.\n"
17353 "\n"
17354 "\n"
17355 "\n"
17356 "SYNOPSIS:\n"
17357 "\n"
17358 "plgra()\n"
17359 "\n"
17360 ""},
17361 { "plgriddata", _wrap_plgriddata, METH_VARARGS, "\n"
17362 "Grid data from irregularly sampled data\n"
17363 "\n"
17364 "DESCRIPTION:\n"
17365 "\n"
17366 " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
17367 " require data organized as a grid, i.e., with x sample point values\n"
17368 " independent of y coordinate and vice versa. This function takes\n"
17369 " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
17370 " vectors; reads the desired grid location from the input vectors\n"
17371 " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
17372 " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
17373 " interpolate the data to the grid is specified with the argument type\n"
17374 " which can have one parameter specified in argument data.\n"
17375 "\n"
17376 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17377 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17378 "\n"
17379 "\n"
17380 " This function is used in example 21.\n"
17381 "\n"
17382 "\n"
17383 "\n"
17384 "SYNOPSIS:\n"
17385 "\n"
17386 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17387 "\n"
17388 "ARGUMENTS:\n"
17389 "\n"
17390 " x (PLFLT_VECTOR, input) : The input x vector.\n"
17391 "\n"
17392 " y (PLFLT_VECTOR, input) : The input y vector.\n"
17393 "\n"
17394 " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
17395 " y[i], z[i] represents one data sample coordinate.\n"
17396 "\n"
17397 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17398 " vectors.\n"
17399 "\n"
17400 " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17401 " in the x direction. Usually xg has nptsx equally spaced values\n"
17402 " from the minimum to the maximum values of the x input vector.\n"
17403 "\n"
17404 " nptsx (PLINT, input) : The number of points in the xg vector.\n"
17405 "\n"
17406 " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17407 " in the y direction. Similar to the xg parameter.\n"
17408 "\n"
17409 " nptsy (PLINT, input) : The number of points in the yg vector.\n"
17410 "\n"
17411 " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
17412 " where data lies in the grid specified by xg and yg. Therefore the\n"
17413 " zg matrix must be dimensioned\n"
17414 " nptsx by\n"
17415 " nptsy.\n"
17416 "\n"
17417 " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17418 " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17419 " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17420 " GRID_NNI: Natural Neighbors Interpolation\n"
17421 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17422 " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17423 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17424 " Weighted\n"
17425 " For details of the algorithms read the source file plgridd.c.\n"
17426 "\n"
17427 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17428 " which can be specified through this argument. Currently, for\n"
17429 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17430 " use, the lower the value, the noisier (more local) the\n"
17431 " approximation is.\n"
17432 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17433 " range [1. .. 2.]. High values enable the usage of very thin\n"
17434 " triangles for interpolation, possibly resulting in error in\n"
17435 " the approximation.\n"
17436 " GRID_NNI, only weights greater than data will be accepted. If\n"
17437 " 0, all weights will be accepted.\n"
17438 "\n"
17439 ""},
17440 { "plgspa", _wrap_plgspa, METH_NOARGS, "\n"
17441 "Get current subpage parameters\n"
17442 "\n"
17443 "DESCRIPTION:\n"
17444 "\n"
17445 " Gets the size of the current subpage in millimeters measured from the\n"
17446 " bottom left hand corner of the output device page or screen. Can be\n"
17447 " used in conjunction with plsvpa for setting the size of a viewport in\n"
17448 " absolute coordinates (millimeters).\n"
17449 "\n"
17450 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17451 "\n"
17452 " This function is used in example 23.\n"
17453 "\n"
17454 "\n"
17455 "\n"
17456 "SYNOPSIS:\n"
17457 "\n"
17458 "plgspa(xmin, xmax, ymin, ymax)\n"
17459 "\n"
17460 "ARGUMENTS:\n"
17461 "\n"
17462 " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17463 " the left hand edge of the subpage in millimeters.\n"
17464 "\n"
17465 " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17466 " the right hand edge of the subpage in millimeters.\n"
17467 "\n"
17468 " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17469 " the bottom edge of the subpage in millimeters.\n"
17470 "\n"
17471 " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17472 " the top edge of the subpage in millimeters.\n"
17473 "\n"
17474 ""},
17475 { "plgstrm", _wrap_plgstrm, METH_NOARGS, "\n"
17476 "Get current stream number\n"
17477 "\n"
17478 "DESCRIPTION:\n"
17479 "\n"
17480 " Gets the number of the current output stream. See also plsstrm.\n"
17481 "\n"
17482 " Redacted form: plgstrm(p_strm)\n"
17483 "\n"
17484 " This function is used in example 1,20.\n"
17485 "\n"
17486 "\n"
17487 "\n"
17488 "SYNOPSIS:\n"
17489 "\n"
17490 "plgstrm(p_strm)\n"
17491 "\n"
17492 "ARGUMENTS:\n"
17493 "\n"
17494 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17495 " stream value.\n"
17496 "\n"
17497 ""},
17498 { "plgver", _wrap_plgver, METH_NOARGS, "\n"
17499 "Get the current library version number\n"
17500 "\n"
17501 "DESCRIPTION:\n"
17502 "\n"
17503 " Get the current library version number. Note: you must have allocated\n"
17504 " space for this (80 characters is safe).\n"
17505 "\n"
17506 " Redacted form: plgver(p_ver)\n"
17507 "\n"
17508 " This function is used in example 1.\n"
17509 "\n"
17510 "\n"
17511 "\n"
17512 "SYNOPSIS:\n"
17513 "\n"
17514 "plgver(p_ver)\n"
17515 "\n"
17516 "ARGUMENTS:\n"
17517 "\n"
17518 " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17519 " (with preallocated length of 80 characters or more) containing the\n"
17520 " PLplot version number.\n"
17521 "\n"
17522 ""},
17523 { "plgvpd", _wrap_plgvpd, METH_NOARGS, "\n"
17524 "Get viewport limits in normalized device coordinates\n"
17525 "\n"
17526 "DESCRIPTION:\n"
17527 "\n"
17528 " Get viewport limits in normalized device coordinates.\n"
17529 "\n"
17530 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17531 "\n"
17532 "\n"
17533 " This function is used in example 31.\n"
17534 "\n"
17535 "\n"
17536 "\n"
17537 "SYNOPSIS:\n"
17538 "\n"
17539 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17540 "\n"
17541 "ARGUMENTS:\n"
17542 "\n"
17543 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17544 " viewport limit of the normalized device coordinate in x.\n"
17545 "\n"
17546 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17547 " viewport limit of the normalized device coordinate in x.\n"
17548 "\n"
17549 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17550 " viewport limit of the normalized device coordinate in y.\n"
17551 "\n"
17552 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17553 " viewport limit of the normalized device coordinate in y.\n"
17554 "\n"
17555 ""},
17556 { "plgvpw", _wrap_plgvpw, METH_NOARGS, "\n"
17557 "Get viewport limits in world coordinates\n"
17558 "\n"
17559 "DESCRIPTION:\n"
17560 "\n"
17561 " Get viewport limits in world coordinates.\n"
17562 "\n"
17563 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17564 "\n"
17565 "\n"
17566 " This function is used in example 31.\n"
17567 "\n"
17568 "\n"
17569 "\n"
17570 "SYNOPSIS:\n"
17571 "\n"
17572 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17573 "\n"
17574 "ARGUMENTS:\n"
17575 "\n"
17576 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17577 " viewport limit of the world coordinate in x.\n"
17578 "\n"
17579 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17580 " viewport limit of the world coordinate in x.\n"
17581 "\n"
17582 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17583 " viewport limit of the world coordinate in y.\n"
17584 "\n"
17585 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17586 " viewport limit of the world coordinate in y.\n"
17587 "\n"
17588 ""},
17589 { "plgxax", _wrap_plgxax, METH_NOARGS, "\n"
17590 "Get x axis parameters\n"
17591 "\n"
17592 "DESCRIPTION:\n"
17593 "\n"
17594 " Returns current values of the p_digmax and p_digits flags for the x\n"
17595 " axis. p_digits is updated after the plot is drawn, so this routine\n"
17596 " should only be called after the call to plbox (or plbox3) is complete.\n"
17597 " See the PLplot documentation for more information.\n"
17598 "\n"
17599 " Redacted form: plgxax(p_digmax, p_digits)\n"
17600 "\n"
17601 " This function is used in example 31.\n"
17602 "\n"
17603 "\n"
17604 "\n"
17605 "SYNOPSIS:\n"
17606 "\n"
17607 "plgxax(p_digmax, p_digits)\n"
17608 "\n"
17609 "ARGUMENTS:\n"
17610 "\n"
17611 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17612 " number of digits for the x axis. If nonzero, the printed label\n"
17613 " has been switched to a floating-point representation when the\n"
17614 " number of digits exceeds this value.\n"
17615 "\n"
17616 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17617 " number of digits for the numeric labels (x axis) from the last\n"
17618 " plot.\n"
17619 "\n"
17620 ""},
17621 { "plgyax", _wrap_plgyax, METH_NOARGS, "\n"
17622 "Get y axis parameters\n"
17623 "\n"
17624 "DESCRIPTION:\n"
17625 "\n"
17626 " Identical to plgxax, except that arguments are flags for y axis. See\n"
17627 " the description of plgxax for more detail.\n"
17628 "\n"
17629 " Redacted form: plgyax(p_digmax, p_digits)\n"
17630 "\n"
17631 " This function is used in example 31.\n"
17632 "\n"
17633 "\n"
17634 "\n"
17635 "SYNOPSIS:\n"
17636 "\n"
17637 "plgyax(p_digmax, p_digits)\n"
17638 "\n"
17639 "ARGUMENTS:\n"
17640 "\n"
17641 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17642 " number of digits for the y axis. If nonzero, the printed label\n"
17643 " has been switched to a floating-point representation when the\n"
17644 " number of digits exceeds this value.\n"
17645 "\n"
17646 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17647 " number of digits for the numeric labels (y axis) from the last\n"
17648 " plot.\n"
17649 "\n"
17650 ""},
17651 { "plgzax", _wrap_plgzax, METH_NOARGS, "\n"
17652 "Get z axis parameters\n"
17653 "\n"
17654 "DESCRIPTION:\n"
17655 "\n"
17656 " Identical to plgxax, except that arguments are flags for z axis. See\n"
17657 " the description of plgxax for more detail.\n"
17658 "\n"
17659 " Redacted form: plgzax(p_digmax, p_digits)\n"
17660 "\n"
17661 " This function is used in example 31.\n"
17662 "\n"
17663 "\n"
17664 "\n"
17665 "SYNOPSIS:\n"
17666 "\n"
17667 "plgzax(p_digmax, p_digits)\n"
17668 "\n"
17669 "ARGUMENTS:\n"
17670 "\n"
17671 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17672 " number of digits for the z axis. If nonzero, the printed label\n"
17673 " has been switched to a floating-point representation when the\n"
17674 " number of digits exceeds this value.\n"
17675 "\n"
17676 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17677 " number of digits for the numeric labels (z axis) from the last\n"
17678 " plot.\n"
17679 "\n"
17680 ""},
17681 { "plhist", _wrap_plhist, METH_VARARGS, "\n"
17682 "Plot a histogram from unbinned data\n"
17683 "\n"
17684 "DESCRIPTION:\n"
17685 "\n"
17686 " Plots a histogram from n data points stored in the data vector. This\n"
17687 " routine bins the data into nbin bins equally spaced between datmin and\n"
17688 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17689 " opt allows, among other things, the histogram either to be plotted in\n"
17690 " an existing window or causes plhist to call plenv with suitable limits\n"
17691 " before plotting the histogram.\n"
17692 "\n"
17693 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17694 "\n"
17695 " This function is used in example 5.\n"
17696 "\n"
17697 "\n"
17698 "\n"
17699 "SYNOPSIS:\n"
17700 "\n"
17701 "plhist(n, data, datmin, datmax, nbin, opt)\n"
17702 "\n"
17703 "ARGUMENTS:\n"
17704 "\n"
17705 " n (PLINT, input) : Number of data points.\n"
17706 "\n"
17707 " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17708 " n data points.\n"
17709 "\n"
17710 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17711 "\n"
17712 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17713 "\n"
17714 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17715 " divide the interval xmin to xmax.\n"
17716 "\n"
17717 " opt (PLINT, input) : Is a combination of several flags:\n"
17718 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17719 " the histogram data, the outer bins are expanded to fill up the\n"
17720 " entire x-axis, data outside the given extremes are assigned to the\n"
17721 " outer bins and bins of zero height are simply drawn.\n"
17722 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17723 " to fit the histogram data, without this flag, plenv is called\n"
17724 " to set the world coordinates.\n"
17725 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17726 " extremes are not taken into account. This option should\n"
17727 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17728 " properly present the data.\n"
17729 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17730 " size as the ones inside.\n"
17731 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17732 " (there is a gap for such bins).\n"
17733 "\n"
17734 ""},
17735 { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, "\n"
17736 "Convert HLS color to RGB\n"
17737 "\n"
17738 "DESCRIPTION:\n"
17739 "\n"
17740 " Convert HLS color coordinates to RGB.\n"
17741 "\n"
17742 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17743 "\n"
17744 "\n"
17745 " This function is used in example 2.\n"
17746 "\n"
17747 "\n"
17748 "\n"
17749 "SYNOPSIS:\n"
17750 "\n"
17751 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17752 "\n"
17753 "ARGUMENTS:\n"
17754 "\n"
17755 " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17756 " cylinder.\n"
17757 "\n"
17758 " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17759 " the axis of the color cylinder.\n"
17760 "\n"
17761 " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17762 " the radius of the color cylinder.\n"
17763 "\n"
17764 " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17765 " (0.0-1.0) of the color.\n"
17766 "\n"
17767 " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17768 " intensity (0.0-1.0) of the color.\n"
17769 "\n"
17770 " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17771 " intensity (0.0-1.0) of the color.\n"
17772 "\n"
17773 ""},
17774 { "plinit", _wrap_plinit, METH_NOARGS, "\n"
17775 "Initialize PLplot\n"
17776 "\n"
17777 "DESCRIPTION:\n"
17778 "\n"
17779 " Initializing the plotting package. The program prompts for the device\n"
17780 " keyword or number of the desired output device. Hitting a RETURN in\n"
17781 " response to the prompt is the same as selecting the first device.\n"
17782 " plinit will issue no prompt if either the device was specified\n"
17783 " previously (via command line flag, the plsetopt function, or the\n"
17784 " plsdev function), or if only one device is enabled when PLplot is\n"
17785 " installed. If subpages have been specified, the output device is\n"
17786 " divided into nx by ny subpages, each of which may be used\n"
17787 " independently. If plinit is called again during a program, the\n"
17788 " previously opened file will be closed. The subroutine pladv is used\n"
17789 " to advance from one subpage to the next.\n"
17790 "\n"
17791 " Redacted form: plinit()\n"
17792 "\n"
17793 " This function is used in all of the examples.\n"
17794 "\n"
17795 "\n"
17796 "\n"
17797 "SYNOPSIS:\n"
17798 "\n"
17799 "plinit()\n"
17800 "\n"
17801 ""},
17802 { "pljoin", _wrap_pljoin, METH_VARARGS, "\n"
17803 "Draw a line between two points\n"
17804 "\n"
17805 "DESCRIPTION:\n"
17806 "\n"
17807 " Joins the point (\n"
17808 " x1,\n"
17809 " y1) to (\n"
17810 " x2,\n"
17811 " y2).\n"
17812 "\n"
17813 " Redacted form: pljoin(x1,y1,x2,y2)\n"
17814 "\n"
17815 " This function is used in examples 3 and 14.\n"
17816 "\n"
17817 "\n"
17818 "\n"
17819 "SYNOPSIS:\n"
17820 "\n"
17821 "pljoin(x1, y1, x2, y2)\n"
17822 "\n"
17823 "ARGUMENTS:\n"
17824 "\n"
17825 " x1 (PLFLT, input) : x coordinate of first point.\n"
17826 "\n"
17827 " y1 (PLFLT, input) : y coordinate of first point.\n"
17828 "\n"
17829 " x2 (PLFLT, input) : x coordinate of second point.\n"
17830 "\n"
17831 " y2 (PLFLT, input) : y coordinate of second point.\n"
17832 "\n"
17833 ""},
17834 { "pllab", _wrap_pllab, METH_VARARGS, "\n"
17835 "Simple routine to write labels\n"
17836 "\n"
17837 "DESCRIPTION:\n"
17838 "\n"
17839 " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17840 "\n"
17841 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17842 "\n"
17843 " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17844 "\n"
17845 "\n"
17846 "\n"
17847 "SYNOPSIS:\n"
17848 "\n"
17849 "pllab(xlabel, ylabel, tlabel)\n"
17850 "\n"
17851 "ARGUMENTS:\n"
17852 "\n"
17853 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17854 " the label for the x axis.\n"
17855 "\n"
17856 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17857 " the label for the y axis.\n"
17858 "\n"
17859 " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17860 " the title of the plot.\n"
17861 "\n"
17862 ""},
17863 { "pllegend", _wrap_pllegend, METH_VARARGS, "\n"
17864 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17865 "\n"
17866 "DESCRIPTION:\n"
17867 "\n"
17868 " Routine for creating a discrete plot legend with a plotted filled box,\n"
17869 " line, and/or line of symbols for each annotated legend entry. (See\n"
17870 " plcolorbar for similar functionality for creating continuous color\n"
17871 " bars.) The arguments of pllegend provide control over the location\n"
17872 " and size of the legend as well as the location and characteristics of\n"
17873 " the elements (most of which are optional) within that legend. The\n"
17874 " resulting legend is clipped at the boundaries of the current subpage.\n"
17875 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17876 " defined in the documentation of the position parameter.)\n"
17877 "\n"
17878 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17879 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17880 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17881 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17882 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17883 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17884 "\n"
17885 " This function is used in examples 4, 26, and 33.\n"
17886 "\n"
17887 "\n"
17888 "\n"
17889 "SYNOPSIS:\n"
17890 "\n"
17891 "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"
17892 "\n"
17893 "ARGUMENTS:\n"
17894 "\n"
17895 " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17896 " legend width in adopted coordinates. This quantity is calculated\n"
17897 " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17898 " the routine depending on nlegend and nrow), and the length\n"
17899 " (calculated internally) of the longest text string.\n"
17900 "\n"
17901 " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17902 " legend height in adopted coordinates. This quantity is calculated\n"
17903 " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17904 " the routine depending on nlegend and nrow).\n"
17905 "\n"
17906 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17907 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17908 " on the left of the legend and the plotted area on the right.\n"
17909 " Otherwise, put the text area on the right of the legend and the\n"
17910 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17911 " plot a (semitransparent) background for the legend. If the\n"
17912 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17913 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17914 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17915 " plot the resulting array of legend entries in row-major order.\n"
17916 " Otherwise, plot the legend entries in column-major order.\n"
17917 "\n"
17918 " position (PLINT, input) : position contains bits which control the\n"
17919 " overall position of the legend and the definition of the adopted\n"
17920 " coordinates used for positions just like what is done for the\n"
17921 " position argument for plcolorbar. However, note that the defaults\n"
17922 " for the position bits (see below) are different than the\n"
17923 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17924 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17925 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17926 " the 16 possible standard positions (the 4 corners and centers of\n"
17927 " the 4 sides for both the inside and outside cases) of the legend\n"
17928 " relative to the adopted coordinate system. The corner positions\n"
17929 " are specified by the appropriate combination of two of the\n"
17930 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17931 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17932 " value of one of those bits. The adopted coordinates are\n"
17933 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17934 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17935 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17936 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17937 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17938 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17939 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17940 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17941 "\n"
17942 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17943 " coordinates from the specified standard position of the legend.\n"
17944 " For positive x, the direction of motion away from the standard\n"
17945 " position is inward/outward from the standard corner positions or\n"
17946 " standard left or right positions if the\n"
17947 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17948 " For the standard top or bottom positions, the direction of motion\n"
17949 " is toward positive X.\n"
17950 "\n"
17951 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17952 " coordinates from the specified standard position of the legend.\n"
17953 " For positive y, the direction of motion away from the standard\n"
17954 " position is inward/outward from the standard corner positions or\n"
17955 " standard top or bottom positions if the\n"
17956 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17957 " the standard left or right positions, the direction of motion is\n"
17958 " toward positive Y.\n"
17959 "\n"
17960 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
17961 " of the plot area (where the colored boxes, lines, and/or lines of\n"
17962 " symbols are drawn) of the legend.\n"
17963 "\n"
17964 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
17965 " legend (PL_LEGEND_BACKGROUND).\n"
17966 "\n"
17967 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
17968 " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
17969 "\n"
17970 " bb_style (PLINT, input) : The pllsty style number for the\n"
17971 " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
17972 "\n"
17973 " nrow (PLINT, input) : The number of rows in the matrix used to\n"
17974 " render the\n"
17975 " nlegend legend entries. For internal transformations of\n"
17976 " nrow, see further remarks under\n"
17977 " nlegend.\n"
17978 "\n"
17979 " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
17980 " to render the\n"
17981 " nlegend legend entries. For internal transformations of\n"
17982 " ncolumn, see further remarks under\n"
17983 " nlegend.\n"
17984 "\n"
17985 " nlegend (PLINT, input) : Number of legend entries. The above\n"
17986 " nrow and\n"
17987 " ncolumn values are transformed internally to be consistent with\n"
17988 " nlegend. If either\n"
17989 " nrow or\n"
17990 " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
17991 " of\n"
17992 " nrow and\n"
17993 " ncolumn is less than\n"
17994 " nlegend, the smaller of the two (or\n"
17995 " nrow, if\n"
17996 " nrow ==\n"
17997 " ncolumn) is increased so the product is >=\n"
17998 " nlegend. Thus, for example, the common\n"
17999 " nrow = 0,\n"
18000 " ncolumn = 0 case is transformed internally to\n"
18001 " nrow =\n"
18002 " nlegend,\n"
18003 " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
18004 " column.\n"
18005 "\n"
18006 " opt_array (PLINT_VECTOR, input) : A vector of\n"
18007 " nlegend values of options to control each individual plotted area\n"
18008 " corresponding to a legend entry. If the\n"
18009 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
18010 " area. If the\n"
18011 " PL_LEGEND_COLOR_BOX,\n"
18012 " PL_LEGEND_LINE, and/or\n"
18013 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
18014 " entry is plotted with a colored box; a line; and/or a line of\n"
18015 " symbols.\n"
18016 "\n"
18017 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
18018 " area in units of character width.\n"
18019 "\n"
18020 " text_scale (PLFLT, input) : Character height scale for text\n"
18021 " annotations.\n"
18022 "\n"
18023 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
18024 " character height from one legend entry to the next.\n"
18025 "\n"
18026 " text_justification (PLFLT, input) : Justification parameter used\n"
18027 " for text justification. The most common values of\n"
18028 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
18029 " is left justified, centred, or right justified within the text\n"
18030 " area, but other values are allowed as well.\n"
18031 "\n"
18032 " text_colors (PLINT_VECTOR, input) : A vector containing\n"
18033 " nlegend cmap0 text colors.\n"
18034 "\n"
18035 " text (PLCHAR_MATRIX, input) : A vector of\n"
18036 " nlegend UTF-8 character strings containing the legend annotations.\n"
18037 "\n"
18038 " box_colors (PLINT_VECTOR, input) : A vector containing\n"
18039 " nlegend cmap0 colors for the discrete colored boxes (\n"
18040 " PL_LEGEND_COLOR_BOX).\n"
18041 "\n"
18042 " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
18043 " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
18044 " PL_LEGEND_COLOR_BOX).\n"
18045 "\n"
18046 " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
18047 " nlegend scales (units of fraction of character height) for the height\n"
18048 " of the discrete colored boxes (\n"
18049 " PL_LEGEND_COLOR_BOX).\n"
18050 "\n"
18051 " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18052 " nlegend line widths for the patterns specified by box_patterns (\n"
18053 " PL_LEGEND_COLOR_BOX).\n"
18054 "\n"
18055 " line_colors (PLINT_VECTOR, input) : A vector containing\n"
18056 " nlegend cmap0 line colors (\n"
18057 " PL_LEGEND_LINE).\n"
18058 "\n"
18059 " line_styles (PLINT_VECTOR, input) : A vector containing\n"
18060 " nlegend line styles (plsty indices) (\n"
18061 " PL_LEGEND_LINE).\n"
18062 "\n"
18063 " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18064 " nlegend line widths (\n"
18065 " PL_LEGEND_LINE).\n"
18066 "\n"
18067 " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
18068 " nlegend cmap0 symbol colors (\n"
18069 " PL_LEGEND_SYMBOL).\n"
18070 "\n"
18071 " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
18072 " nlegend scale values for the symbol height (\n"
18073 " PL_LEGEND_SYMBOL).\n"
18074 "\n"
18075 " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
18076 " nlegend numbers of symbols to be drawn across the width of the plotted\n"
18077 " area (\n"
18078 " PL_LEGEND_SYMBOL).\n"
18079 "\n"
18080 " symbols (PLCHAR_MATRIX, input) : A vector of\n"
18081 " nlegend UTF-8 character strings containing the legend symbols. (\n"
18082 " PL_LEGEND_SYMBOL).\n"
18083 "\n"
18084 ""},
18085 { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, "\n"
18086 "Plot color bar for image, shade or gradient plots\n"
18087 "\n"
18088 "DESCRIPTION:\n"
18089 "\n"
18090 " Routine for creating a continuous color bar for image, shade, or\n"
18091 " gradient plots. (See pllegend for similar functionality for creating\n"
18092 " legends with discrete elements). The arguments of plcolorbar provide\n"
18093 " control over the location and size of the color bar as well as the\n"
18094 " location and characteristics of the elements (most of which are\n"
18095 " optional) within that color bar. The resulting color bar is clipped\n"
18096 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
18097 " system used for some of the parameters is defined in the documentation\n"
18098 " of the position parameter.)\n"
18099 "\n"
18100 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
18101 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
18102 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
18103 " labels, axis_opts, ticks, sub_ticks, values)\n"
18104 "\n"
18105 " This function is used in examples 16 and 33.\n"
18106 "\n"
18107 "\n"
18108 "\n"
18109 "SYNOPSIS:\n"
18110 "\n"
18111 "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"
18112 "\n"
18113 "ARGUMENTS:\n"
18114 "\n"
18115 " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18116 " labelled and decorated color bar width in adopted coordinates.\n"
18117 "\n"
18118 " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18119 " labelled and decorated color bar height in adopted coordinates.\n"
18120 "\n"
18121 " opt (PLINT, input) : opt contains bits controlling the overall\n"
18122 " color bar. The orientation (direction of the maximum value) of\n"
18123 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
18124 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
18125 " specified, the default orientation is toward the top if the\n"
18126 " colorbar is placed on the left or right of the viewport or toward\n"
18127 " the right if the colorbar is placed on the top or bottom of the\n"
18128 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
18129 " (semitransparent) background for the color bar. If the\n"
18130 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
18131 " color bar. The type of color bar must be specified with one of\n"
18132 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
18133 " more than one of those bits is set only the first one in the above\n"
18134 " list is honored. The position of the (optional) label/title can be\n"
18135 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
18136 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
18137 " will be drawn. If more than one of this list of bits is specified,\n"
18138 " only the first one on the list is honored. End-caps for the color\n"
18139 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
18140 " If a particular color bar cap option is not specified then no cap\n"
18141 " will be drawn for that end. As a special case for\n"
18142 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
18143 " specified. If this option is provided then any tick marks and tick\n"
18144 " labels will be placed at the breaks between shaded segments. TODO:\n"
18145 " This should be expanded to support custom placement of tick marks\n"
18146 " and tick labels at custom value locations for any color bar type.\n"
18147 "\n"
18148 " position (PLINT, input) : position contains bits which control the\n"
18149 " overall position of the color bar and the definition of the\n"
18150 " adopted coordinates used for positions just like what is done for\n"
18151 " the position argument for pllegend. However, note that the\n"
18152 " defaults for the position bits (see below) are different than the\n"
18153 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
18154 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
18155 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
18156 " the 16 possible standard positions (the 4 corners and centers of\n"
18157 " the 4 sides for both the inside and outside cases) of the color\n"
18158 " bar relative to the adopted coordinate system. The corner\n"
18159 " positions are specified by the appropriate combination of two of\n"
18160 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
18161 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
18162 " value of one of those bits. The adopted coordinates are\n"
18163 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
18164 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
18165 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
18166 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
18167 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
18168 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
18169 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
18170 " PL_POSITION_VIEWPORT.\n"
18171 "\n"
18172 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
18173 " coordinates from the specified standard position of the color bar.\n"
18174 " For positive x, the direction of motion away from the standard\n"
18175 " position is inward/outward from the standard corner positions or\n"
18176 " standard left or right positions if the\n"
18177 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18178 " For the standard top or bottom positions, the direction of motion\n"
18179 " is toward positive X.\n"
18180 "\n"
18181 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
18182 " coordinates from the specified standard position of the color bar.\n"
18183 " For positive y, the direction of motion away from the standard\n"
18184 " position is inward/outward from the standard corner positions or\n"
18185 " standard top or bottom positions if the\n"
18186 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18187 " For the standard left or right positions, the direction of motion\n"
18188 " is toward positive Y.\n"
18189 "\n"
18190 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
18191 " the X direction in adopted coordinates.\n"
18192 "\n"
18193 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
18194 " the Y direction in adopted coordinates.\n"
18195 "\n"
18196 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18197 " color bar (PL_COLORBAR_BACKGROUND).\n"
18198 "\n"
18199 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18200 " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
18201 "\n"
18202 " bb_style (PLINT, input) : The pllsty style number for the\n"
18203 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
18204 "\n"
18205 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
18206 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
18207 "\n"
18208 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
18209 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
18210 "\n"
18211 " cont_color (PLINT, input) : The cmap0 contour color for\n"
18212 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
18213 " it will be interpreted according to the design of plshades.\n"
18214 "\n"
18215 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18216 " plots. This is passed directly to plshades, so it will be\n"
18217 " interpreted according to the design of plshades.\n"
18218 "\n"
18219 " n_labels (PLINT, input) : Number of labels to place around the\n"
18220 " color bar.\n"
18221 "\n"
18222 " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
18223 " n_labels labels.\n"
18224 "\n"
18225 " labels (PLCHAR_MATRIX, input) : A vector of\n"
18226 " n_labels UTF-8 character strings containing the labels for the color\n"
18227 " bar. Ignored if no label position is specified with one of the\n"
18228 " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18229 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18230 " corresponding label_opts field.\n"
18231 "\n"
18232 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18233 " value must be greater than 0. It is typically 1 (numerical axis\n"
18234 " labels are provided for one of the long edges of the color bar),\n"
18235 " but it can be larger if multiple numerical axis labels for the\n"
18236 " long edges of the color bar are desired.\n"
18237 "\n"
18238 " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
18239 " n_axes ascii character strings containing options (interpreted as for\n"
18240 " plbox) for the color bar's axis definitions.\n"
18241 "\n"
18242 " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
18243 " spacing of the major tick marks (interpreted as for plbox) for the\n"
18244 " color bar's axis definitions.\n"
18245 "\n"
18246 " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
18247 " number of subticks (interpreted as for plbox) for the color bar's\n"
18248 " axis definitions.\n"
18249 "\n"
18250 " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
18251 " elements in each of the n_axes rows of the values matrix.\n"
18252 "\n"
18253 " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
18254 " values for the data range represented by the color bar. For a row\n"
18255 " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
18256 " elements in the row is specified by n_values[i_axis]. For\n"
18257 " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
18258 " is 2, and the corresponding row elements of the values matrix are\n"
18259 " the minimum and maximum value represented by the colorbar. For\n"
18260 " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
18261 " of the values matrix is interpreted the same as the nlevel and\n"
18262 " clevel arguments of plshades.\n"
18263 "\n"
18264 ""},
18265 { "pllightsource", _wrap_pllightsource, METH_VARARGS, "\n"
18266 "Sets the 3D position of the light source\n"
18267 "\n"
18268 "DESCRIPTION:\n"
18269 "\n"
18270 " Sets the 3D position of the light source for use with plsurf3d and\n"
18271 " plsurf3dl\n"
18272 "\n"
18273 " Redacted form: pllightsource(x, y, z)\n"
18274 "\n"
18275 " This function is used in example 8.\n"
18276 "\n"
18277 "\n"
18278 "\n"
18279 "SYNOPSIS:\n"
18280 "\n"
18281 "pllightsource(x, y, z)\n"
18282 "\n"
18283 "ARGUMENTS:\n"
18284 "\n"
18285 " x (PLFLT, input) : X-coordinate of the light source.\n"
18286 "\n"
18287 " y (PLFLT, input) : Y-coordinate of the light source.\n"
18288 "\n"
18289 " z (PLFLT, input) : Z-coordinate of the light source.\n"
18290 "\n"
18291 ""},
18292 { "plline", _wrap_plline, METH_VARARGS, "\n"
18293 "Draw a line\n"
18294 "\n"
18295 "DESCRIPTION:\n"
18296 "\n"
18297 " Draws line defined by n points in x and y.\n"
18298 "\n"
18299 " Redacted form: plline(x, y)\n"
18300 "\n"
18301 " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
18302 " 25-27, and 29.\n"
18303 "\n"
18304 "\n"
18305 "\n"
18306 "SYNOPSIS:\n"
18307 "\n"
18308 "plline(n, x, y)\n"
18309 "\n"
18310 "ARGUMENTS:\n"
18311 "\n"
18312 " n (PLINT, input) : Number of points defining line.\n"
18313 "\n"
18314 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18315 " points.\n"
18316 "\n"
18317 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18318 " points.\n"
18319 "\n"
18320 ""},
18321 { "plline3", _wrap_plline3, METH_VARARGS, "\n"
18322 "Draw a line in 3 space\n"
18323 "\n"
18324 "DESCRIPTION:\n"
18325 "\n"
18326 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18327 " first set up the viewport, the 2d viewing window (in world\n"
18328 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18329 " more info.\n"
18330 "\n"
18331 " Redacted form: plline3(x, y, z)\n"
18332 "\n"
18333 " This function is used in example 18.\n"
18334 "\n"
18335 "\n"
18336 "\n"
18337 "SYNOPSIS:\n"
18338 "\n"
18339 "plline3(n, x, y, z)\n"
18340 "\n"
18341 "ARGUMENTS:\n"
18342 "\n"
18343 " n (PLINT, input) : Number of points defining line.\n"
18344 "\n"
18345 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18346 " points.\n"
18347 "\n"
18348 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18349 " points.\n"
18350 "\n"
18351 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18352 " points.\n"
18353 "\n"
18354 ""},
18355 { "pllsty", _wrap_pllsty, METH_O, "\n"
18356 "Select line style\n"
18357 "\n"
18358 "DESCRIPTION:\n"
18359 "\n"
18360 " This sets the line style according to one of eight predefined patterns\n"
18361 " (also see plstyl).\n"
18362 "\n"
18363 " Redacted form: pllsty(lin)\n"
18364 "\n"
18365 " This function is used in examples 9, 12, 22, and 25.\n"
18366 "\n"
18367 "\n"
18368 "\n"
18369 "SYNOPSIS:\n"
18370 "\n"
18371 "pllsty(lin)\n"
18372 "\n"
18373 "ARGUMENTS:\n"
18374 "\n"
18375 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18376 " a continuous line, line style 2 is a line with short dashes and\n"
18377 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18378 " 4 has long dashes and short gaps and so on.\n"
18379 "\n"
18380 ""},
18381 { "plmesh", _wrap_plmesh, METH_VARARGS, "\n"
18382 "Plot surface mesh\n"
18383 "\n"
18384 "DESCRIPTION:\n"
18385 "\n"
18386 " Plots a surface mesh within the environment set up by plw3d. The\n"
18387 " surface is defined by the matrix z[\n"
18388 " nx][\n"
18389 " ny] , the point z[i][j] being the value of the function at (\n"
18390 " x[i],\n"
18391 " y[j]). Note that the points in vectors x and y do not need to be\n"
18392 " equally spaced, but must be stored in ascending order. The parameter\n"
18393 " opt controls the way in which the surface is displayed. For further\n"
18394 " details see the PLplot documentation.\n"
18395 "\n"
18396 " Redacted form: plmesh(x, y, z, opt)\n"
18397 "\n"
18398 " This function is used in example 11.\n"
18399 "\n"
18400 "\n"
18401 "\n"
18402 "SYNOPSIS:\n"
18403 "\n"
18404 "plmesh(x, y, z, nx, ny, opt)\n"
18405 "\n"
18406 "ARGUMENTS:\n"
18407 "\n"
18408 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18409 " which the function is evaluated.\n"
18410 "\n"
18411 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18412 " which the function is evaluated.\n"
18413 "\n"
18414 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18415 " plot. Should have dimensions of\n"
18416 " nx by\n"
18417 " ny.\n"
18418 "\n"
18419 " nx (PLINT, input) : Number of x values at which function has been\n"
18420 " evaluated.\n"
18421 "\n"
18422 " ny (PLINT, input) : Number of y values at which function has been\n"
18423 " evaluated.\n"
18424 "\n"
18425 " opt (PLINT, input) : Determines the way in which the surface is\n"
18426 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18427 " function of x for each value of y[j] .\n"
18428 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18429 " for each value of x[i] .\n"
18430 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18431 " at which function is defined.\n"
18432 "\n"
18433 ""},
18434 { "plmeshc", _wrap_plmeshc, METH_VARARGS, "\n"
18435 "Magnitude colored plot surface mesh with contour\n"
18436 "\n"
18437 "DESCRIPTION:\n"
18438 "\n"
18439 " A more powerful form of plmesh: the surface mesh can be colored\n"
18440 " accordingly to the current z value being plotted, a contour plot can\n"
18441 " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18442 " plotted function border and the base XY plane.\n"
18443 "\n"
18444 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18445 "\n"
18446 " This function is used in example 11.\n"
18447 "\n"
18448 "\n"
18449 "\n"
18450 "SYNOPSIS:\n"
18451 "\n"
18452 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18453 "\n"
18454 "ARGUMENTS:\n"
18455 "\n"
18456 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18457 " which the function is evaluated.\n"
18458 "\n"
18459 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18460 " which the function is evaluated.\n"
18461 "\n"
18462 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18463 " plot. Should have dimensions of\n"
18464 " nx by\n"
18465 " ny.\n"
18466 "\n"
18467 " nx (PLINT, input) : Number of x values at which function is\n"
18468 " evaluated.\n"
18469 "\n"
18470 " ny (PLINT, input) : Number of y values at which function is\n"
18471 " evaluated.\n"
18472 "\n"
18473 " opt (PLINT, input) : Determines the way in which the surface is\n"
18474 " represented. To specify more than one option just add the options,\n"
18475 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18476 " showing z as a function of x for each value of y[j] .\n"
18477 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18478 " for each value of x[i] .\n"
18479 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18480 " at which function is defined.\n"
18481 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18482 " the z value being plotted. The color is used from the current\n"
18483 " cmap1.\n"
18484 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18485 " using parameters\n"
18486 " nlevel and\n"
18487 " clevel.\n"
18488 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18489 " the borders of the plotted function.\n"
18490 "\n"
18491 "\n"
18492 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18493 " levels.\n"
18494 "\n"
18495 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18496 "\n"
18497 ""},
18498 { "plmkstrm", _wrap_plmkstrm, METH_NOARGS, "\n"
18499 "Creates a new stream and makes it the default\n"
18500 "\n"
18501 "DESCRIPTION:\n"
18502 "\n"
18503 " Creates a new stream and makes it the default. Differs from using\n"
18504 " plsstrm, in that a free stream number is found, and returned.\n"
18505 " Unfortunately, I have to start at stream 1 and work upward, since\n"
18506 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18507 " that no initial, library-opening call is required. So stream 0 must\n"
18508 " be preallocated, and there is no simple way of determining whether it\n"
18509 " is already in use or not.\n"
18510 "\n"
18511 " Redacted form: plmkstrm(p_strm)\n"
18512 "\n"
18513 " This function is used in examples 1 and 20.\n"
18514 "\n"
18515 "\n"
18516 "\n"
18517 "SYNOPSIS:\n"
18518 "\n"
18519 "plmkstrm(p_strm)\n"
18520 "\n"
18521 "ARGUMENTS:\n"
18522 "\n"
18523 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18524 " number of the created stream.\n"
18525 "\n"
18526 ""},
18527 { "plmtex", _wrap_plmtex, METH_VARARGS, "\n"
18528 "Write text relative to viewport boundaries\n"
18529 "\n"
18530 "DESCRIPTION:\n"
18531 "\n"
18532 " Writes text at a specified position relative to the viewport\n"
18533 " boundaries. Text may be written inside or outside the viewport, but\n"
18534 " is clipped at the subpage boundaries. The reference point of a string\n"
18535 " lies along a line passing through the string at half the height of a\n"
18536 " capital letter. The position of the reference point along this line\n"
18537 " is determined by just, and the position of the reference point\n"
18538 " relative to the viewport is set by disp and pos.\n"
18539 "\n"
18540 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18541 "\n"
18542 "\n"
18543 " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18544 " 26.\n"
18545 "\n"
18546 "\n"
18547 "\n"
18548 "SYNOPSIS:\n"
18549 "\n"
18550 "plmtex(side, disp, pos, just, text)\n"
18551 "\n"
18552 "ARGUMENTS:\n"
18553 "\n"
18554 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18555 " the side of the viewport along which the text is to be written.\n"
18556 " The string must be one of: b: Bottom of viewport, text written\n"
18557 " parallel to edge.\n"
18558 " bv: Bottom of viewport, text written at right angles to edge.\n"
18559 " l: Left of viewport, text written parallel to edge.\n"
18560 " lv: Left of viewport, text written at right angles to edge.\n"
18561 " r: Right of viewport, text written parallel to edge.\n"
18562 " rv: Right of viewport, text written at right angles to edge.\n"
18563 " t: Top of viewport, text written parallel to edge.\n"
18564 " tv: Top of viewport, text written at right angles to edge.\n"
18565 "\n"
18566 "\n"
18567 " disp (PLFLT, input) : Position of the reference point of string,\n"
18568 " measured outwards from the specified viewport edge in units of the\n"
18569 " current character height. Use negative disp to write within the\n"
18570 " viewport.\n"
18571 "\n"
18572 " pos (PLFLT, input) : Position of the reference point of string\n"
18573 " along the specified edge, expressed as a fraction of the length of\n"
18574 " the edge.\n"
18575 "\n"
18576 " just (PLFLT, input) : Specifies the position of the string relative\n"
18577 " to its reference point. If just=0. , the reference point is at\n"
18578 " the left and if just=1. , it is at the right of the string. Other\n"
18579 " values of just give intermediate justifications.\n"
18580 "\n"
18581 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18582 " written out.\n"
18583 "\n"
18584 ""},
18585 { "plmtex3", _wrap_plmtex3, METH_VARARGS, "\n"
18586 "Write text relative to viewport boundaries in 3D plots\n"
18587 "\n"
18588 "DESCRIPTION:\n"
18589 "\n"
18590 " Writes text at a specified position relative to the viewport\n"
18591 " boundaries. Text may be written inside or outside the viewport, but\n"
18592 " is clipped at the subpage boundaries. The reference point of a string\n"
18593 " lies along a line passing through the string at half the height of a\n"
18594 " capital letter. The position of the reference point along this line\n"
18595 " is determined by just, and the position of the reference point\n"
18596 " relative to the viewport is set by disp and pos.\n"
18597 "\n"
18598 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18599 "\n"
18600 " This function is used in example 28.\n"
18601 "\n"
18602 "\n"
18603 "\n"
18604 "SYNOPSIS:\n"
18605 "\n"
18606 "plmtex3(side, disp, pos, just, text)\n"
18607 "\n"
18608 "ARGUMENTS:\n"
18609 "\n"
18610 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18611 " the side of the viewport along which the text is to be written.\n"
18612 " The string should contain one or more of the following characters:\n"
18613 " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18614 " only label the X axis, not both the X and Y axes. x: Label the X\n"
18615 " axis.\n"
18616 " y: Label the Y axis.\n"
18617 " z: Label the Z axis.\n"
18618 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18619 " For X it is the axis that starts at y-min. For Y it is the\n"
18620 " axis that starts at x-min.\n"
18621 " s: Label the secondary axis.\n"
18622 " v: Draw the text perpendicular to the axis.\n"
18623 "\n"
18624 "\n"
18625 " disp (PLFLT, input) : Position of the reference point of string,\n"
18626 " measured outwards from the specified viewport edge in units of the\n"
18627 " current character height. Use negative disp to write within the\n"
18628 " viewport.\n"
18629 "\n"
18630 " pos (PLFLT, input) : Position of the reference point of string\n"
18631 " along the specified edge, expressed as a fraction of the length of\n"
18632 " the edge.\n"
18633 "\n"
18634 " just (PLFLT, input) : Specifies the position of the string relative\n"
18635 " to its reference point. If just=0. , the reference point is at\n"
18636 " the left and if just=1. , it is at the right of the string. Other\n"
18637 " values of just give intermediate justifications.\n"
18638 "\n"
18639 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18640 " written out.\n"
18641 "\n"
18642 ""},
18643 { "plot3d", _wrap_plot3d, METH_VARARGS, "\n"
18644 "Plot 3-d surface plot\n"
18645 "\n"
18646 "DESCRIPTION:\n"
18647 "\n"
18648 " Plots a three-dimensional surface plot within the environment set up\n"
18649 " by plw3d. The surface is defined by the matrix z[\n"
18650 " nx][\n"
18651 " ny] , the point z[i][j] being the value of the function at (\n"
18652 " x[i],\n"
18653 " y[j]). Note that the points in vectors x and y do not need to be\n"
18654 " equally spaced, but must be stored in ascending order. The parameter\n"
18655 " opt controls the way in which the surface is displayed. For further\n"
18656 " details see the PLplot documentation. The only difference between\n"
18657 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18658 " while plot3d only draws the surface as viewed from the top.\n"
18659 "\n"
18660 " Redacted form: plot3d(x, y, z, opt, side)\n"
18661 "\n"
18662 " This function is used in examples 11 and 21.\n"
18663 "\n"
18664 "\n"
18665 "\n"
18666 "SYNOPSIS:\n"
18667 "\n"
18668 "plot3d(x, y, z, nx, ny, opt, side)\n"
18669 "\n"
18670 "ARGUMENTS:\n"
18671 "\n"
18672 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18673 " which the function is evaluated.\n"
18674 "\n"
18675 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18676 " which the function is evaluated.\n"
18677 "\n"
18678 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18679 " plot. Should have dimensions of\n"
18680 " nx by\n"
18681 " ny.\n"
18682 "\n"
18683 " nx (PLINT, input) : Number of x values at which function is\n"
18684 " evaluated.\n"
18685 "\n"
18686 " ny (PLINT, input) : Number of y values at which function is\n"
18687 " evaluated.\n"
18688 "\n"
18689 " opt (PLINT, input) : Determines the way in which the surface is\n"
18690 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18691 " function of x for each value of y[j] .\n"
18692 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18693 " for each value of x[i] .\n"
18694 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18695 " at which function is defined.\n"
18696 "\n"
18697 "\n"
18698 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18699 " should be draw on the figure. If side is true sides are drawn,\n"
18700 " otherwise no sides are drawn.\n"
18701 "\n"
18702 ""},
18703 { "plot3dc", _wrap_plot3dc, METH_VARARGS, "\n"
18704 "Magnitude colored plot surface with contour\n"
18705 "\n"
18706 "DESCRIPTION:\n"
18707 "\n"
18708 " Aside from dropping the\n"
18709 " side functionality this is a more powerful form of plot3d: the surface\n"
18710 " mesh can be colored accordingly to the current z value being plotted,\n"
18711 " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18712 " drawn between the plotted function border and the base XY plane. The\n"
18713 " arguments are identical to those of plmeshc. The only difference\n"
18714 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18715 " the surface, while plot3dc only draws the surface as viewed from the\n"
18716 " top.\n"
18717 "\n"
18718 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18719 "\n"
18720 "\n"
18721 " This function is used in example 21.\n"
18722 "\n"
18723 "\n"
18724 "\n"
18725 "SYNOPSIS:\n"
18726 "\n"
18727 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18728 "\n"
18729 "ARGUMENTS:\n"
18730 "\n"
18731 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18732 " which the function is evaluated.\n"
18733 "\n"
18734 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18735 " which the function is evaluated.\n"
18736 "\n"
18737 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18738 " plot. Should have dimensions of\n"
18739 " nx by\n"
18740 " ny.\n"
18741 "\n"
18742 " nx (PLINT, input) : Number of x values at which function is\n"
18743 " evaluated.\n"
18744 "\n"
18745 " ny (PLINT, input) : Number of y values at which function is\n"
18746 " evaluated.\n"
18747 "\n"
18748 " opt (PLINT, input) : Determines the way in which the surface is\n"
18749 " represented. To specify more than one option just add the options,\n"
18750 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18751 " showing z as a function of x for each value of y[j] .\n"
18752 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18753 " for each value of x[i] .\n"
18754 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18755 " at which function is defined.\n"
18756 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18757 " the z value being plotted. The color is used from the current\n"
18758 " cmap1.\n"
18759 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18760 " using parameters\n"
18761 " nlevel and\n"
18762 " clevel.\n"
18763 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18764 " the borders of the plotted function.\n"
18765 "\n"
18766 "\n"
18767 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18768 " levels.\n"
18769 "\n"
18770 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18771 "\n"
18772 ""},
18773 { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, "\n"
18774 "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18775 "\n"
18776 "DESCRIPTION:\n"
18777 "\n"
18778 " When the implementation is completed this variant of plot3dc (see that\n"
18779 " function's documentation for more details) should be suitable for the\n"
18780 " case where the area of the x, y coordinate grid where z is defined can\n"
18781 " be non-rectangular. The implementation is incomplete so the last 4\n"
18782 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18783 " indexymax; are currently ignored and the functionality is otherwise\n"
18784 " identical to that of plot3dc.\n"
18785 "\n"
18786 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18787 " indexymin, indexymax)\n"
18788 "\n"
18789 "\n"
18790 " This function is not used in any example.\n"
18791 "\n"
18792 "\n"
18793 "\n"
18794 "SYNOPSIS:\n"
18795 "\n"
18796 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18797 "\n"
18798 "ARGUMENTS:\n"
18799 "\n"
18800 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18801 " which the function is evaluated.\n"
18802 "\n"
18803 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18804 " which the function is evaluated.\n"
18805 "\n"
18806 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18807 " plot. Should have dimensions of\n"
18808 " nx by\n"
18809 " ny.\n"
18810 "\n"
18811 " nx (PLINT, input) : Number of x values at which the function is\n"
18812 " evaluated.\n"
18813 "\n"
18814 " ny (PLINT, input) : Number of y values at which the function is\n"
18815 " evaluated.\n"
18816 "\n"
18817 " opt (PLINT, input) : Determines the way in which the surface is\n"
18818 " represented. To specify more than one option just add the options,\n"
18819 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18820 " showing z as a function of x for each value of y[j] .\n"
18821 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18822 " for each value of x[i] .\n"
18823 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18824 " at which function is defined.\n"
18825 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18826 " the z value being plotted. The color is used from the current\n"
18827 " cmap1.\n"
18828 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18829 " using parameters\n"
18830 " nlevel and\n"
18831 " clevel.\n"
18832 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18833 " the borders of the plotted function.\n"
18834 "\n"
18835 "\n"
18836 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18837 " levels.\n"
18838 "\n"
18839 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18840 "\n"
18841 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18842 " corresponds to the first x index where z is defined.\n"
18843 "\n"
18844 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18845 " which corresponds (by convention) to one more than the last x\n"
18846 " index value where z is defined.\n"
18847 "\n"
18848 " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18849 " values which all must be ≥ 0. These values are the first y index\n"
18850 " where z is defined for a particular x index in the range from\n"
18851 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18852 " indexxmax.\n"
18853 "\n"
18854 " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18855 " values which all must be ≤ ny. These values correspond (by\n"
18856 " convention) to one more than the last y index where z is defined\n"
18857 " for a particular x index in the range from indexxmin to indexxmax\n"
18858 " - 1. The dimension of indexymax is indexxmax.\n"
18859 "\n"
18860 ""},
18861 { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, "\n"
18862 "Plot shaded 3-d surface plot\n"
18863 "\n"
18864 "DESCRIPTION:\n"
18865 "\n"
18866 " Plots a three-dimensional shaded surface plot within the environment\n"
18867 " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18868 " z[\n"
18869 " nx][\n"
18870 " ny], the point z[i][j] being the value of the function at (\n"
18871 " x[i],\n"
18872 " y[j]). Note that the points in vectors x and y do not need to be\n"
18873 " equally spaced, but must be stored in ascending order. For further\n"
18874 " details see the PLplot documentation.\n"
18875 "\n"
18876 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18877 "\n"
18878 " This function is not used in any examples.\n"
18879 "\n"
18880 "\n"
18881 "\n"
18882 "SYNOPSIS:\n"
18883 "\n"
18884 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18885 "\n"
18886 "ARGUMENTS:\n"
18887 "\n"
18888 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18889 " which the function is evaluated.\n"
18890 "\n"
18891 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18892 " which the function is evaluated.\n"
18893 "\n"
18894 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18895 " plot. Should have dimensions of\n"
18896 " nx by\n"
18897 " ny.\n"
18898 "\n"
18899 " nx (PLINT, input) : Number of x values at which function is\n"
18900 " evaluated.\n"
18901 "\n"
18902 " ny (PLINT, input) : Number of y values at which function is\n"
18903 " evaluated.\n"
18904 "\n"
18905 " opt (PLINT, input) : Determines the way in which the surface is\n"
18906 " represented. To specify more than one option just add the options,\n"
18907 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18908 " connecting points at which function is defined.\n"
18909 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18910 " using parameters\n"
18911 " nlevel and\n"
18912 " clevel.\n"
18913 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18914 " using parameters\n"
18915 " nlevel and\n"
18916 " clevel.\n"
18917 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18918 " the borders of the plotted function.\n"
18919 " opt=MAG_COLOR : the surface is colored according to the value\n"
18920 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18921 " according to the intensity of the reflected light in the\n"
18922 " surface from a light source whose position is set using\n"
18923 " pllightsource.\n"
18924 "\n"
18925 "\n"
18926 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18927 " levels.\n"
18928 "\n"
18929 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18930 "\n"
18931 ""},
18932 { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, "\n"
18933 "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18934 "\n"
18935 "DESCRIPTION:\n"
18936 "\n"
18937 " This variant of plsurf3d (see that function's documentation for more\n"
18938 " details) should be suitable for the case where the area of the x, y\n"
18939 " coordinate grid where z is defined can be non-rectangular. The limits\n"
18940 " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18941 " indexymin, and indexymax.\n"
18942 "\n"
18943 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18944 " indexymax)\n"
18945 "\n"
18946 " This function is used in example 8.\n"
18947 "\n"
18948 "\n"
18949 "\n"
18950 "SYNOPSIS:\n"
18951 "\n"
18952 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18953 "\n"
18954 "ARGUMENTS:\n"
18955 "\n"
18956 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18957 " which the function is evaluated.\n"
18958 "\n"
18959 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18960 " which the function is evaluated.\n"
18961 "\n"
18962 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18963 " plot. Should have dimensions of\n"
18964 " nx by\n"
18965 " ny.\n"
18966 "\n"
18967 " nx (PLINT, input) : Number of x values at which function is\n"
18968 " evaluated.\n"
18969 "\n"
18970 " ny (PLINT, input) : Number of y values at which function is\n"
18971 " evaluated.\n"
18972 "\n"
18973 " opt (PLINT, input) : Determines the way in which the surface is\n"
18974 " represented. To specify more than one option just add the options,\n"
18975 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18976 " connecting points at which function is defined.\n"
18977 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18978 " using parameters\n"
18979 " nlevel and\n"
18980 " clevel.\n"
18981 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18982 " using parameters\n"
18983 " nlevel and\n"
18984 " clevel.\n"
18985 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18986 " the borders of the plotted function.\n"
18987 " opt=MAG_COLOR : the surface is colored according to the value\n"
18988 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18989 " according to the intensity of the reflected light in the\n"
18990 " surface from a light source whose position is set using\n"
18991 " pllightsource.\n"
18992 "\n"
18993 "\n"
18994 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18995 " levels.\n"
18996 "\n"
18997 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18998 "\n"
18999 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
19000 " corresponds to the first x index where z is defined.\n"
19001 "\n"
19002 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
19003 " which corresponds (by convention) to one more than the last x\n"
19004 " index value where z is defined.\n"
19005 "\n"
19006 " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
19007 " values which all must be ≥ 0. These values are the first y index\n"
19008 " where z is defined for a particular x index in the range from\n"
19009 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
19010 " indexxmax.\n"
19011 "\n"
19012 " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
19013 " values which all must be ≤ ny. These values correspond (by\n"
19014 " convention) to one more than the last y index where z is defined\n"
19015 " for a particular x index in the range from indexxmin to indexxmax\n"
19016 " - 1. The dimension of indexymax is indexxmax.\n"
19017 "\n"
19018 ""},
19019 { "plparseopts", _wrap_plparseopts, METH_VARARGS, "\n"
19020 "Parse command-line arguments\n"
19021 "\n"
19022 "DESCRIPTION:\n"
19023 "\n"
19024 " Parse command-line arguments.\n"
19025 "\n"
19026 " plparseopts removes all recognized flags (decreasing argc\n"
19027 " accordingly), so that invalid input may be readily detected. It can\n"
19028 " also be used to process user command line flags. The user can merge\n"
19029 " an option table of type PLOptionTable into the internal option table\n"
19030 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
19031 " the external table(s) be parsed by calling plClearOpts before\n"
19032 " plMergeOpts.\n"
19033 "\n"
19034 " The default action taken by plparseopts is as follows:\n"
19035 " Returns with an error if an unrecognized option or badly formed\n"
19036 " option-value pair are encountered.\n"
19037 " Returns immediately (return code 0) when the first non-option command\n"
19038 " line argument is found.\n"
19039 " Returns with the return code of the option handler, if one was called.\n"
19040 "\n"
19041 " Deletes command line arguments from argv list as they are found, and\n"
19042 " decrements argc accordingly.\n"
19043 " Does not show \"invisible\" options in usage or help messages.\n"
19044 " Assumes the program name is contained in argv[0].\n"
19045 "\n"
19046 " These behaviors may be controlled through the\n"
19047 " mode argument.\n"
19048 "\n"
19049 " Redacted form: General: plparseopts(argv, mode)\n"
19050 "\n"
19051 "\n"
19052 " This function is used in all of the examples.\n"
19053 "\n"
19054 "\n"
19055 "\n"
19056 "SYNOPSIS:\n"
19057 "\n"
19058 "PLINT plparseopts(p_argc, argv, mode)\n"
19059 "\n"
19060 "ARGUMENTS:\n"
19061 "\n"
19062 " p_argc (int *, input/output) : Number of arguments.\n"
19063 "\n"
19064 " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
19065 " strings containing *p_argc command-line arguments.\n"
19066 "\n"
19067 " mode (PLINT, input) : Parsing mode with the following\n"
19068 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
19069 " and all error messages enabled, including program exit when an\n"
19070 " error occurs. Anything on the command line that isn't recognized\n"
19071 " as a valid option or option argument is flagged as an error.\n"
19072 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
19073 " of errors.\n"
19074 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
19075 " arguments.\n"
19076 " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
19077 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
19078 " pointer to the program name.\n"
19079 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
19080 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
19081 " unrecognized arguments.\n"
19082 "\n"
19083 ""},
19084 { "plpat", _wrap_plpat, METH_VARARGS, "\n"
19085 "Set area line fill pattern\n"
19086 "\n"
19087 "DESCRIPTION:\n"
19088 "\n"
19089 " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
19090 " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
19091 " inclinations and spacings. The arguments to this routine are the\n"
19092 " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
19093 " elements) specifying the inclinations in tenths of a degree and the\n"
19094 " spacing in micrometers. (See also plpsty)\n"
19095 "\n"
19096 " Redacted form: General: plpat(inc, del)\n"
19097 "\n"
19098 "\n"
19099 " This function is used in example 15.\n"
19100 "\n"
19101 "\n"
19102 "\n"
19103 "SYNOPSIS:\n"
19104 "\n"
19105 "plpat(nlin, inc, del)\n"
19106 "\n"
19107 "ARGUMENTS:\n"
19108 "\n"
19109 " nlin (PLINT, input) : Number of sets of lines making up the\n"
19110 " pattern, either 1 or 2.\n"
19111 "\n"
19112 " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19113 " inclination in tenths of a degree. (Should be between -900 and\n"
19114 " 900).\n"
19115 "\n"
19116 " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19117 " spacing in micrometers between the lines making up the pattern.\n"
19118 "\n"
19119 ""},
19120 { "plpath", _wrap_plpath, METH_VARARGS, "\n"
19121 "Draw a line between two points, accounting for coordinate transforms\n"
19122 "\n"
19123 "DESCRIPTION:\n"
19124 "\n"
19125 " Joins the point (\n"
19126 " x1,\n"
19127 " y1) to (\n"
19128 " x2,\n"
19129 " y2) . If a global coordinate transform is defined then the line is\n"
19130 " broken in to n segments to approximate the path. If no transform is\n"
19131 " defined then this simply acts like a call to pljoin.\n"
19132 "\n"
19133 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
19134 "\n"
19135 " This function is used in example 22.\n"
19136 "\n"
19137 "\n"
19138 "\n"
19139 "SYNOPSIS:\n"
19140 "\n"
19141 "plpath(n, x1, y1, x2, y2)\n"
19142 "\n"
19143 "ARGUMENTS:\n"
19144 "\n"
19145 " n (PLINT, input) : number of points to use to approximate the path.\n"
19146 "\n"
19147 " x1 (PLFLT, input) : x coordinate of first point.\n"
19148 "\n"
19149 " y1 (PLFLT, input) : y coordinate of first point.\n"
19150 "\n"
19151 " x2 (PLFLT, input) : x coordinate of second point.\n"
19152 "\n"
19153 " y2 (PLFLT, input) : y coordinate of second point.\n"
19154 "\n"
19155 ""},
19156 { "plpoin", _wrap_plpoin, METH_VARARGS, "\n"
19157 "Plot a glyph at the specified points\n"
19158 "\n"
19159 "DESCRIPTION:\n"
19160 "\n"
19161 " Plot a glyph at the specified points. (This function is largely\n"
19162 " superseded by plstring which gives access to many[!] more glyphs.)\n"
19163 " code=-1 means try to just draw a point. Right now it's just a move\n"
19164 " and a draw at the same place. Not ideal, since a sufficiently\n"
19165 " intelligent output device may optimize it away, or there may be faster\n"
19166 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19167 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19168 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19169 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19170 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19171 "\n"
19172 " Redacted form: plpoin(x, y, code)\n"
19173 "\n"
19174 " This function is used in examples 1, 6, 14, and 29.\n"
19175 "\n"
19176 "\n"
19177 "\n"
19178 "SYNOPSIS:\n"
19179 "\n"
19180 "plpoin(n, x, y, code)\n"
19181 "\n"
19182 "ARGUMENTS:\n"
19183 "\n"
19184 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19185 "\n"
19186 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19187 " points.\n"
19188 "\n"
19189 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19190 " points.\n"
19191 "\n"
19192 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19193 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19194 " each of the n points.\n"
19195 "\n"
19196 ""},
19197 { "plpoin3", _wrap_plpoin3, METH_VARARGS, "\n"
19198 "Plot a glyph at the specified 3D points\n"
19199 "\n"
19200 "DESCRIPTION:\n"
19201 "\n"
19202 " Plot a glyph at the specified 3D points. (This function is largely\n"
19203 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
19204 " Set up the call to this function similar to what is done for plline3.\n"
19205 " code=-1 means try to just draw a point. Right now it's just a move\n"
19206 " and a draw at the same place. Not ideal, since a sufficiently\n"
19207 " intelligent output device may optimize it away, or there may be faster\n"
19208 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19209 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19210 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19211 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19212 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19213 "\n"
19214 " Redacted form: plpoin3(x, y, z, code)\n"
19215 "\n"
19216 " This function is not used in any example.\n"
19217 "\n"
19218 "\n"
19219 "\n"
19220 "SYNOPSIS:\n"
19221 "\n"
19222 "plpoin3(n, x, y, z, code)\n"
19223 "\n"
19224 "ARGUMENTS:\n"
19225 "\n"
19226 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19227 "\n"
19228 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19229 " points.\n"
19230 "\n"
19231 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19232 " points.\n"
19233 "\n"
19234 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
19235 " points.\n"
19236 "\n"
19237 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19238 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19239 " each of the n points.\n"
19240 "\n"
19241 ""},
19242 { "plpoly3", _wrap_plpoly3, METH_VARARGS, "\n"
19243 "Draw a polygon in 3 space\n"
19244 "\n"
19245 "DESCRIPTION:\n"
19246 "\n"
19247 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19248 " like plline3, but differs from that function in that plpoly3 attempts\n"
19249 " to determine if the polygon is viewable depending on the order of the\n"
19250 " points within the vector and the value of ifcc. If the back of\n"
19251 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19252 " you want, then use plline3 instead.\n"
19253 "\n"
19254 " The points are assumed to be in a plane, and the directionality of the\n"
19255 " plane is determined from the first three points. Additional points do\n"
19256 " not have to lie on the plane defined by the first three, but if they\n"
19257 " do not, then the determination of visibility obviously can't be 100%\n"
19258 " accurate... So if you're 3 space polygons are too far from planar,\n"
19259 " consider breaking them into smaller polygons. 3 points define a plane\n"
19260 " :-).\n"
19261 "\n"
19262 " Bugs: If one of the first two segments is of zero length, or if they\n"
19263 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19264 " being correct. Avoid such situations :-). See x18c.c for an example\n"
19265 " of this problem. (Search for 20.1).\n"
19266 "\n"
19267 " Redacted form: plpoly3(x, y, z, code)\n"
19268 "\n"
19269 " This function is used in example 18.\n"
19270 "\n"
19271 "\n"
19272 "\n"
19273 "SYNOPSIS:\n"
19274 "\n"
19275 "plpoly3(n, x, y, z, draw, ifcc)\n"
19276 "\n"
19277 "ARGUMENTS:\n"
19278 "\n"
19279 " n (PLINT, input) : Number of points defining line.\n"
19280 "\n"
19281 " x (PLFLT_VECTOR, input) : A vector containing\n"
19282 " n x coordinates of points.\n"
19283 "\n"
19284 " y (PLFLT_VECTOR, input) : A vector containing\n"
19285 " n y coordinates of points.\n"
19286 "\n"
19287 " z (PLFLT_VECTOR, input) : A vector containing\n"
19288 " n z coordinates of points.\n"
19289 "\n"
19290 " draw (PLBOOL_VECTOR, input) : A vector containing\n"
19291 " n-1 Boolean values which control drawing the segments of the polygon.\n"
19292 " If draw[i] is true, then the polygon segment from index [i] to\n"
19293 " [i+1] is drawn, otherwise, not.\n"
19294 "\n"
19295 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19296 " polygon is determined by assuming the points are laid out in a\n"
19297 " counter-clockwise order. Otherwise, the directionality of the\n"
19298 " polygon is determined by assuming the points are laid out in a\n"
19299 " clockwise order.\n"
19300 "\n"
19301 ""},
19302 { "plprec", _wrap_plprec, METH_VARARGS, "\n"
19303 "Set precision in numeric labels\n"
19304 "\n"
19305 "DESCRIPTION:\n"
19306 "\n"
19307 " Sets the number of places after the decimal point in numeric labels.\n"
19308 "\n"
19309 " Redacted form: plprec(setp, prec)\n"
19310 "\n"
19311 " This function is used in example 29.\n"
19312 "\n"
19313 "\n"
19314 "\n"
19315 "SYNOPSIS:\n"
19316 "\n"
19317 "plprec(setp, prec)\n"
19318 "\n"
19319 "ARGUMENTS:\n"
19320 "\n"
19321 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19322 " automatically determines the number of places to use after the\n"
19323 " decimal point in numeric labels (like those used to label axes).\n"
19324 " If setp is 1 then prec sets the number of places.\n"
19325 "\n"
19326 " prec (PLINT, input) : The number of characters to draw after the\n"
19327 " decimal point in numeric labels.\n"
19328 "\n"
19329 ""},
19330 { "plpsty", _wrap_plpsty, METH_O, "\n"
19331 "Select area fill pattern\n"
19332 "\n"
19333 "DESCRIPTION:\n"
19334 "\n"
19335 " If\n"
19336 " patt is zero or less use either a hardware solid fill if the drivers\n"
19337 " have that capability (virtually all do) or fall back to a software\n"
19338 " emulation of a solid fill using the eighth area line fill pattern. If\n"
19339 " 0 <\n"
19340 " patt <= 8, then select one of eight predefined area line fill patterns\n"
19341 " to use (see plpat if you desire other patterns).\n"
19342 "\n"
19343 " Redacted form: plpsty(patt)\n"
19344 "\n"
19345 " This function is used in examples 12, 13, 15, 16, and 25.\n"
19346 "\n"
19347 "\n"
19348 "\n"
19349 "SYNOPSIS:\n"
19350 "\n"
19351 "plpsty(patt)\n"
19352 "\n"
19353 "ARGUMENTS:\n"
19354 "\n"
19355 " patt (PLINT, input) : The desired pattern index. If\n"
19356 " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
19357 " above) used. For\n"
19358 " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
19359 " line fill capability itself (most deliberately do not so that line\n"
19360 " fill patterns look identical for those drivers), the patterns\n"
19361 " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
19362 " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
19363 " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
19364 " (8) lines at both 45 degrees and -45 degrees.\n"
19365 "\n"
19366 ""},
19367 { "plptex", _wrap_plptex, METH_VARARGS, "\n"
19368 "Write text inside the viewport\n"
19369 "\n"
19370 "DESCRIPTION:\n"
19371 "\n"
19372 " Writes text at a specified position and inclination within the\n"
19373 " viewport. Text is clipped at the viewport boundaries. The reference\n"
19374 " point of a string lies along a line passing through the string at half\n"
19375 " the height of a capital letter. The position of the reference point\n"
19376 " along this line is determined by just, the reference point is placed\n"
19377 " at world coordinates (\n"
19378 " x,\n"
19379 " y) within the viewport. The inclination of the string is specified\n"
19380 " in terms of differences of world coordinates making it easy to write\n"
19381 " text parallel to a line in a graph.\n"
19382 "\n"
19383 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19384 "\n"
19385 " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
19386 "\n"
19387 "\n"
19388 "\n"
19389 "SYNOPSIS:\n"
19390 "\n"
19391 "plptex(x, y, dx, dy, just, text)\n"
19392 "\n"
19393 "ARGUMENTS:\n"
19394 "\n"
19395 " x (PLFLT, input) : x coordinate of reference point of string.\n"
19396 "\n"
19397 " y (PLFLT, input) : y coordinate of reference point of string.\n"
19398 "\n"
19399 " dx (PLFLT, input) : Together with dy, this specifies the\n"
19400 " inclination of the string. The baseline of the string is parallel\n"
19401 " to a line joining (\n"
19402 " x,\n"
19403 " y) to (\n"
19404 " x+\n"
19405 " dx,\n"
19406 " y+\n"
19407 " dy) .\n"
19408 "\n"
19409 " dy (PLFLT, input) : Together with dx, this specifies the\n"
19410 " inclination of the string.\n"
19411 "\n"
19412 " just (PLFLT, input) : Specifies the position of the string relative\n"
19413 " to its reference point. If just=0. , the reference point is at\n"
19414 " the left and if just=1. , it is at the right of the string. Other\n"
19415 " values of just give intermediate justifications.\n"
19416 "\n"
19417 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19418 " written out.\n"
19419 "\n"
19420 ""},
19421 { "plptex3", _wrap_plptex3, METH_VARARGS, "\n"
19422 "Write text inside the viewport of a 3D plot\n"
19423 "\n"
19424 "DESCRIPTION:\n"
19425 "\n"
19426 " Writes text at a specified position and inclination and with a\n"
19427 " specified shear within the viewport. Text is clipped at the viewport\n"
19428 " boundaries. The reference point of a string lies along a line passing\n"
19429 " through the string at half the height of a capital letter. The\n"
19430 " position of the reference point along this line is determined by just,\n"
19431 " and the reference point is placed at world coordinates (\n"
19432 " wx,\n"
19433 " wy,\n"
19434 " wz) within the viewport. The inclination and shear of the string is\n"
19435 " specified in terms of differences of world coordinates making it easy\n"
19436 " to write text parallel to a line in a graph.\n"
19437 "\n"
19438 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19439 "\n"
19440 " This function is used in example 28.\n"
19441 "\n"
19442 "\n"
19443 "\n"
19444 "SYNOPSIS:\n"
19445 "\n"
19446 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19447 "\n"
19448 "ARGUMENTS:\n"
19449 "\n"
19450 " wx (PLFLT, input) : x world coordinate of reference point of\n"
19451 " string.\n"
19452 "\n"
19453 " wy (PLFLT, input) : y world coordinate of reference point of\n"
19454 " string.\n"
19455 "\n"
19456 " wz (PLFLT, input) : z world coordinate of reference point of\n"
19457 " string.\n"
19458 "\n"
19459 " dx (PLFLT, input) : Together with dy and\n"
19460 " dz , this specifies the inclination of the string. The baseline of\n"
19461 " the string is parallel to a line joining (\n"
19462 " x,\n"
19463 " y,\n"
19464 " z) to (\n"
19465 " x+\n"
19466 " dx,\n"
19467 " y+\n"
19468 " dy,\n"
19469 " z+\n"
19470 " dz) .\n"
19471 "\n"
19472 " dy (PLFLT, input) : Together with dx and\n"
19473 " dz, this specifies the inclination of the string.\n"
19474 "\n"
19475 " dz (PLFLT, input) : Together with dx and\n"
19476 " dy, this specifies the inclination of the string.\n"
19477 "\n"
19478 " sx (PLFLT, input) : Together with sy and\n"
19479 " sz , this specifies the shear of the string. The string is sheared so\n"
19480 " that the characters are vertically parallel to a line joining (\n"
19481 " x,\n"
19482 " y,\n"
19483 " z) to (\n"
19484 " x+\n"
19485 " sx,\n"
19486 " y+\n"
19487 " sy,\n"
19488 " z+\n"
19489 " sz) . If sx =\n"
19490 " sy =\n"
19491 " sz = 0.) then the text is not sheared.\n"
19492 "\n"
19493 " sy (PLFLT, input) : Together with sx and\n"
19494 " sz, this specifies shear of the string.\n"
19495 "\n"
19496 " sz (PLFLT, input) : Together with sx and\n"
19497 " sy, this specifies shear of the string.\n"
19498 "\n"
19499 " just (PLFLT, input) : Specifies the position of the string relative\n"
19500 " to its reference point. If just=0. , the reference point is at\n"
19501 " the left and if just=1. , it is at the right of the string. Other\n"
19502 " values of just give intermediate justifications.\n"
19503 "\n"
19504 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19505 " written out.\n"
19506 "\n"
19507 ""},
19508 { "plrandd", _wrap_plrandd, METH_NOARGS, "\n"
19509 "Random number generator returning a real random number in the range [0,1]\n"
19510 "\n"
19511 "DESCRIPTION:\n"
19512 "\n"
19513 " Random number generator returning a real random number in the range\n"
19514 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19515 " / compilers provide their own random number generator, and so this is\n"
19516 " provided purely for convenience and to give a consistent random number\n"
19517 " generator across all languages supported by PLplot. This is\n"
19518 " particularly useful for comparing results from the test suite of\n"
19519 " examples.\n"
19520 "\n"
19521 " Redacted form: plrandd()\n"
19522 "\n"
19523 " This function is used in examples 17 and 21.\n"
19524 "\n"
19525 "\n"
19526 "\n"
19527 "SYNOPSIS:\n"
19528 "\n"
19529 "plrandd()\n"
19530 "\n"
19531 ""},
19532 { "plreplot", _wrap_plreplot, METH_NOARGS, "\n"
19533 "Replays contents of plot buffer to current device/file\n"
19534 "\n"
19535 "DESCRIPTION:\n"
19536 "\n"
19537 " Replays contents of plot buffer to current device/file.\n"
19538 "\n"
19539 " Redacted form: plreplot()\n"
19540 "\n"
19541 " This function is used in example 1,20.\n"
19542 "\n"
19543 "\n"
19544 "\n"
19545 "SYNOPSIS:\n"
19546 "\n"
19547 "plreplot()\n"
19548 "\n"
19549 ""},
19550 { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, "\n"
19551 "Convert RGB color to HLS\n"
19552 "\n"
19553 "DESCRIPTION:\n"
19554 "\n"
19555 " Convert RGB color coordinates to HLS\n"
19556 "\n"
19557 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19558 "\n"
19559 "\n"
19560 " This function is used in example 2.\n"
19561 "\n"
19562 "\n"
19563 "\n"
19564 "SYNOPSIS:\n"
19565 "\n"
19566 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19567 "\n"
19568 "ARGUMENTS:\n"
19569 "\n"
19570 " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19571 "\n"
19572 " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19573 "\n"
19574 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19575 "\n"
19576 " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19577 " degrees (0.0-360.0) on the color cylinder.\n"
19578 "\n"
19579 " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19580 " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19581 " cylinder.\n"
19582 "\n"
19583 " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19584 " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19585 " cylinder.\n"
19586 "\n"
19587 ""},
19588 { "plschr", _wrap_plschr, METH_VARARGS, "\n"
19589 "Set character size\n"
19590 "\n"
19591 "DESCRIPTION:\n"
19592 "\n"
19593 " This sets up the size of all subsequent characters drawn. The actual\n"
19594 " height of a character is the product of the default character size and\n"
19595 " a scaling factor.\n"
19596 "\n"
19597 " Redacted form: plschr(def, scale)\n"
19598 "\n"
19599 " This function is used in examples 2, 13, 23, and 24.\n"
19600 "\n"
19601 "\n"
19602 "\n"
19603 "SYNOPSIS:\n"
19604 "\n"
19605 "plschr(def, scale)\n"
19606 "\n"
19607 "ARGUMENTS:\n"
19608 "\n"
19609 " def (PLFLT, input) : The default height of a character in\n"
19610 " millimeters, should be set to zero if the default height is to\n"
19611 " remain unchanged. For rasterized drivers the dx and dy values\n"
19612 " specified in plspage are used to convert from mm to pixels (note\n"
19613 " the different unit systems used). This dpi aware scaling is not\n"
19614 " implemented for all drivers yet.\n"
19615 "\n"
19616 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19617 " actual character height.\n"
19618 "\n"
19619 ""},
19620 { "plscmap0", _wrap_plscmap0, METH_VARARGS, "\n"
19621 "Set cmap0 colors by 8-bit RGB values\n"
19622 "\n"
19623 "DESCRIPTION:\n"
19624 "\n"
19625 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19626 " documentation). This sets the entire color map -- only as many colors\n"
19627 " as specified will be allocated.\n"
19628 "\n"
19629 " Redacted form: plscmap0(r, g, b)\n"
19630 "\n"
19631 " This function is used in examples 2 and 24.\n"
19632 "\n"
19633 "\n"
19634 "\n"
19635 "SYNOPSIS:\n"
19636 "\n"
19637 "plscmap0(r, g, b, ncol0)\n"
19638 "\n"
19639 "ARGUMENTS:\n"
19640 "\n"
19641 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19642 " integers (0-255) representing the degree of red in the color.\n"
19643 "\n"
19644 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19645 " integers (0-255) representing the degree of green in the color.\n"
19646 "\n"
19647 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19648 " integers (0-255) representing the degree of blue in the color.\n"
19649 "\n"
19650 " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19651 "\n"
19652 ""},
19653 { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, "\n"
19654 "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19655 "\n"
19656 "DESCRIPTION:\n"
19657 "\n"
19658 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19659 " and PLFLT alpha transparency value. This sets the entire color map --\n"
19660 " only as many colors as specified will be allocated.\n"
19661 "\n"
19662 " Redacted form: plscmap0a(r, g, b, alpha)\n"
19663 "\n"
19664 " This function is used in examples 30.\n"
19665 "\n"
19666 "\n"
19667 "\n"
19668 "SYNOPSIS:\n"
19669 "\n"
19670 "plscmap0a(r, g, b, alpha, ncol0)\n"
19671 "\n"
19672 "ARGUMENTS:\n"
19673 "\n"
19674 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19675 " integers (0-255) representing the degree of red in the color.\n"
19676 "\n"
19677 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19678 " integers (0-255) representing the degree of green in the color.\n"
19679 "\n"
19680 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19681 " integers (0-255) representing the degree of blue in the color.\n"
19682 "\n"
19683 " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19684 " representing the alpha transparency of the color.\n"
19685 "\n"
19686 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19687 " vectors.\n"
19688 "\n"
19689 ""},
19690 { "plscmap0n", _wrap_plscmap0n, METH_O, "\n"
19691 "Set number of colors in cmap0\n"
19692 "\n"
19693 "DESCRIPTION:\n"
19694 "\n"
19695 " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19696 " (or reallocate) cmap0, and fill with default values for those colors\n"
19697 " not previously allocated. The first 16 default colors are given in\n"
19698 " the plcol0 documentation. For larger indices the default color is\n"
19699 " red.\n"
19700 "\n"
19701 " The drivers are not guaranteed to support more than 16 colors.\n"
19702 "\n"
19703 " Redacted form: plscmap0n(ncol0)\n"
19704 "\n"
19705 " This function is used in examples 15, 16, and 24.\n"
19706 "\n"
19707 "\n"
19708 "\n"
19709 "SYNOPSIS:\n"
19710 "\n"
19711 "plscmap0n(ncol0)\n"
19712 "\n"
19713 "ARGUMENTS:\n"
19714 "\n"
19715 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19716 " the cmap0 palette. If this number is zero or less, then the value\n"
19717 " from the previous call to plscmap0n is used and if there is no\n"
19718 " previous call, then a default value is used.\n"
19719 "\n"
19720 ""},
19721 { "plscmap1", _wrap_plscmap1, METH_VARARGS, "\n"
19722 "Set opaque RGB cmap1 colors values\n"
19723 "\n"
19724 "DESCRIPTION:\n"
19725 "\n"
19726 " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19727 " vector values. This function also sets the number of cmap1 colors.\n"
19728 " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19729 " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19730 " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19731 " to\n"
19732 " ncol1-1. So in order for this continuous color model to work\n"
19733 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19734 " that these RGB vectors are continuous functions of their integer\n"
19735 " indices.\n"
19736 "\n"
19737 " Redacted form: plscmap1(r, g, b)\n"
19738 "\n"
19739 " This function is used in example 31.\n"
19740 "\n"
19741 "\n"
19742 "\n"
19743 "SYNOPSIS:\n"
19744 "\n"
19745 "plscmap1(r, g, b, ncol1)\n"
19746 "\n"
19747 "ARGUMENTS:\n"
19748 "\n"
19749 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19750 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19751 " color as a continuous function of the integer index of the vector.\n"
19752 "\n"
19753 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19754 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19755 " color as a continuous function of the integer index of the vector.\n"
19756 "\n"
19757 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19758 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19759 " color as a continuous function of the integer index of the vector.\n"
19760 "\n"
19761 " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19762 "\n"
19763 ""},
19764 { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, "\n"
19765 "Set semitransparent cmap1 RGBA colors.\n"
19766 "\n"
19767 "DESCRIPTION:\n"
19768 "\n"
19769 " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19770 " RGBA vector values. This function also sets the number of cmap1\n"
19771 " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19772 " floating-point index in the range from 0.0-1.0 which is linearly\n"
19773 " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19774 " vectors in the range from 0 to\n"
19775 " ncol1-1. So in order for this continuous color model to work\n"
19776 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19777 " that these RGBA vectors are continuous functions of their integer\n"
19778 " indices.\n"
19779 "\n"
19780 " Redacted form: plscmap1a(r, g, b, alpha)\n"
19781 "\n"
19782 " This function is used in example 31.\n"
19783 "\n"
19784 "\n"
19785 "\n"
19786 "SYNOPSIS:\n"
19787 "\n"
19788 "plscmap1a(r, g, b, alpha, ncol1)\n"
19789 "\n"
19790 "ARGUMENTS:\n"
19791 "\n"
19792 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19793 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19794 " color as a continuous function of the integer index of the vector.\n"
19795 "\n"
19796 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19797 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19798 " color as a continuous function of the integer index of the vector.\n"
19799 "\n"
19800 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19801 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19802 " color as a continuous function of the integer index of the vector.\n"
19803 "\n"
19804 " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19805 " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19806 " completely transparent and 1.0 corresponds to completely opaque)\n"
19807 " the alpha transparency of the color as a continuous function of\n"
19808 " the integer index of the vector.\n"
19809 "\n"
19810 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19811 " vectors.\n"
19812 "\n"
19813 ""},
19814 { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, "\n"
19815 "Set cmap1 colors using a piece-wise linear relationship\n"
19816 "\n"
19817 "DESCRIPTION:\n"
19818 "\n"
19819 " Set cmap1 colors using a piece-wise linear relationship between the\n"
19820 " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19821 " (see the PLplot documentation). May be called at any time.\n"
19822 "\n"
19823 " The idea here is to specify a number of control points that define the\n"
19824 " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19825 " these points, linear interpolation is used which gives a smooth\n"
19826 " variation of color with intensity index. Any number of control points\n"
19827 " may be specified, located at arbitrary positions, although typically 2\n"
19828 " - 4 are enough. Another way of stating this is that we are traversing\n"
19829 " a given number of lines through HLS or RGB space as we move through\n"
19830 " cmap1 intensity indices. The control points at the minimum and\n"
19831 " maximum position (0 and 1) must always be specified. By adding more\n"
19832 " control points you can get more variation. One good technique for\n"
19833 " plotting functions that vary about some expected average is to use an\n"
19834 " additional 2 control points in the center (position ~= 0.5) that are\n"
19835 " the same lightness as the background (typically white for paper\n"
19836 " output, black for crt), and same hue as the boundary control points.\n"
19837 " This allows the highs and lows to be very easily distinguished.\n"
19838 "\n"
19839 " Each control point must specify the cmap1 intensity index and the\n"
19840 " associated three coordinates in HLS or RGB space. The first point\n"
19841 " must correspond to position = 0, and the last to position = 1.\n"
19842 "\n"
19843 " If RGB colors are provided then the interpolation takes place in RGB\n"
19844 " space and is trivial. However if HLS colors are provided then, because\n"
19845 " of the circular nature of the color wheel for the hue coordinate, the\n"
19846 " interpolation could be performed in either direction around the color\n"
19847 " wheel. The default behaviour is for the hue to be linearly\n"
19848 " interpolated ignoring this circular property of hue. So for example,\n"
19849 " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19850 " green and cyan. If instead you wish to interpolate the other way\n"
19851 " around the color wheel you have two options. You may provide hues\n"
19852 " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19853 " for red the interpolation will proceed via magenta. Alternatively you\n"
19854 " can utilise the alt_hue_path variable to reverse the direction of\n"
19855 " interpolation if you need to provide hues within the [0-360) range.\n"
19856 "\n"
19857 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19858 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19859 " -120]falsegreen-yellow-red-magenta-blue[240\n"
19860 " 480]falseblue-magenta-red-yellow-green[120\n"
19861 " 240]truegreen-yellow-red-magenta-blue[240\n"
19862 " 120]trueblue-magenta-red-yellow-green\n"
19863 "\n"
19864 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19865 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19866 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19867 "\n"
19868 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19869 " alt_hue_path)\n"
19870 "\n"
19871 " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19872 "\n"
19873 "\n"
19874 "\n"
19875 "SYNOPSIS:\n"
19876 "\n"
19877 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19878 "\n"
19879 "ARGUMENTS:\n"
19880 "\n"
19881 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19882 "\n"
19883 " npts (PLINT, input) : number of control points\n"
19884 "\n"
19885 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19886 " intensity index (0.0-1.0) in ascending order for each control\n"
19887 " point.\n"
19888 "\n"
19889 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19890 " coordinate (H or R) for each control point.\n"
19891 "\n"
19892 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19893 " coordinate (L or G) for each control point.\n"
19894 "\n"
19895 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19896 " coordinate (S or B) for each control point.\n"
19897 "\n"
19898 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19899 " npts - 1 elements), each containing either true to use the reversed\n"
19900 " HLS interpolation or false to use the regular HLS interpolation.\n"
19901 " (alt_hue_path[i] refers to the interpolation interval between the\n"
19902 " i and i + 1 control points). This parameter is not used for RGB\n"
19903 " colors (\n"
19904 " itype = true).\n"
19905 "\n"
19906 ""},
19907 { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, "\n"
19908 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19909 "\n"
19910 "DESCRIPTION:\n"
19911 "\n"
19912 " This is a variant of plscmap1l that supports alpha channel\n"
19913 " transparency. It sets cmap1 colors using a piece-wise linear\n"
19914 " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19915 " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19916 " transparency value (0.0-1.0). It may be called at any time.\n"
19917 "\n"
19918 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19919 " alpha, alt_hue_path)\n"
19920 "\n"
19921 " This function is used in example 30.\n"
19922 "\n"
19923 "\n"
19924 "\n"
19925 "SYNOPSIS:\n"
19926 "\n"
19927 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19928 "\n"
19929 "ARGUMENTS:\n"
19930 "\n"
19931 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19932 "\n"
19933 " npts (PLINT, input) : number of control points.\n"
19934 "\n"
19935 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19936 " intensity index (0.0-1.0) in ascending order for each control\n"
19937 " point.\n"
19938 "\n"
19939 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19940 " coordinate (H or R) for each control point.\n"
19941 "\n"
19942 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19943 " coordinate (L or G) for each control point.\n"
19944 "\n"
19945 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19946 " coordinate (S or B) for each control point.\n"
19947 "\n"
19948 " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19949 " transparency value (0.0-1.0) for each control point.\n"
19950 "\n"
19951 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19952 " npts - 1 elements) containing the alternative interpolation method\n"
19953 " Boolean value for each control point interval. (alt_hue_path[i]\n"
19954 " refers to the interpolation interval between the i and i + 1\n"
19955 " control points).\n"
19956 "\n"
19957 ""},
19958 { "plscmap1n", _wrap_plscmap1n, METH_O, "\n"
19959 "Set number of colors in cmap1\n"
19960 "\n"
19961 "DESCRIPTION:\n"
19962 "\n"
19963 " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
19964 " values if this is the first allocation (see the PLplot documentation).\n"
19965 "\n"
19966 " Redacted form: plscmap1n(ncol1)\n"
19967 "\n"
19968 " This function is used in examples 8, 11, 20, and 21.\n"
19969 "\n"
19970 "\n"
19971 "\n"
19972 "SYNOPSIS:\n"
19973 "\n"
19974 "plscmap1n(ncol1)\n"
19975 "\n"
19976 "ARGUMENTS:\n"
19977 "\n"
19978 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
19979 " the cmap1 palette. If this number is zero or less, then the value\n"
19980 " from the previous call to plscmap1n is used and if there is no\n"
19981 " previous call, then a default value is used.\n"
19982 "\n"
19983 ""},
19984 { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, "\n"
19985 "Set the cmap1 argument range for continuous color plots\n"
19986 "\n"
19987 "DESCRIPTION:\n"
19988 "\n"
19989 " Set the cmap1 argument range for continuous color plots that\n"
19990 " corresponds to the range of data values. The maximum range\n"
19991 " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
19992 " the cmap1 argument range that is specified with this routine, the\n"
19993 " smaller the subset of the cmap1 color palette that is used to\n"
19994 " represent the continuous data being plotted. If\n"
19995 " min_color is greater than\n"
19996 " max_color or\n"
19997 " max_color is greater than 1.0 or\n"
19998 " min_color is less than 0.0 then no change is made to the cmap1\n"
19999 " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
20000 "\n"
20001 " Redacted form: plscmap1_range(min_color, max_color)\n"
20002 "\n"
20003 " This function is currently used in example 33.\n"
20004 "\n"
20005 "\n"
20006 "\n"
20007 "SYNOPSIS:\n"
20008 "\n"
20009 "plscmap1_range(min_color, max_color)\n"
20010 "\n"
20011 "ARGUMENTS:\n"
20012 "\n"
20013 " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
20014 " than 0.0, then 0.0 is used instead.\n"
20015 "\n"
20016 " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
20017 " than 1.0, then 1.0 is used instead.\n"
20018 "\n"
20019 ""},
20020 { "plgcmap1_range", _wrap_plgcmap1_range, METH_NOARGS, "\n"
20021 "Get the cmap1 argument range for continuous color plots\n"
20022 "\n"
20023 "DESCRIPTION:\n"
20024 "\n"
20025 " Get the cmap1 argument range for continuous color plots. (Use\n"
20026 " plscmap1_range to set the cmap1 argument range.)\n"
20027 "\n"
20028 " Redacted form: plgcmap1_range(min_color, max_color)\n"
20029 "\n"
20030 " This function is currently not used in any example.\n"
20031 "\n"
20032 "\n"
20033 "\n"
20034 "SYNOPSIS:\n"
20035 "\n"
20036 "plgcmap1_range(min_color, max_color)\n"
20037 "\n"
20038 "ARGUMENTS:\n"
20039 "\n"
20040 " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20041 " minimum cmap1 argument.\n"
20042 "\n"
20043 " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20044 " maximum cmap1 argument.\n"
20045 "\n"
20046 ""},
20047 { "plscol0", _wrap_plscol0, METH_VARARGS, "\n"
20048 "Set 8-bit RGB values for given cmap0 color index\n"
20049 "\n"
20050 "DESCRIPTION:\n"
20051 "\n"
20052 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
20053 " index. Overwrites the previous color value for the given index and,\n"
20054 " thus, does not result in any additional allocation of space for\n"
20055 " colors.\n"
20056 "\n"
20057 " Redacted form: plscol0(icol0, r, g, b)\n"
20058 "\n"
20059 " This function is used in any example 31.\n"
20060 "\n"
20061 "\n"
20062 "\n"
20063 "SYNOPSIS:\n"
20064 "\n"
20065 "plscol0(icol0, r, g, b)\n"
20066 "\n"
20067 "ARGUMENTS:\n"
20068 "\n"
20069 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20070 " number of colors (which is set by default, by plscmap0n, or even\n"
20071 " by plscmap0).\n"
20072 "\n"
20073 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20074 " degree of red in the color.\n"
20075 "\n"
20076 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20077 " degree of green in the color.\n"
20078 "\n"
20079 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20080 " degree of blue in the color.\n"
20081 "\n"
20082 ""},
20083 { "plscol0a", _wrap_plscol0a, METH_VARARGS, "\n"
20084 "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
20085 "\n"
20086 "DESCRIPTION:\n"
20087 "\n"
20088 " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
20089 " (see the PLplot documentation) index. Overwrites the previous color\n"
20090 " value for the given index and, thus, does not result in any additional\n"
20091 " allocation of space for colors.\n"
20092 "\n"
20093 " This function is used in example 30.\n"
20094 "\n"
20095 "\n"
20096 "\n"
20097 "SYNOPSIS:\n"
20098 "\n"
20099 "plscol0a(icol0, r, g, b, alpha)\n"
20100 "\n"
20101 "ARGUMENTS:\n"
20102 "\n"
20103 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20104 " number of colors (which is set by default, by plscmap0n, or even\n"
20105 " by plscmap0).\n"
20106 "\n"
20107 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20108 " degree of red in the color.\n"
20109 "\n"
20110 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20111 " degree of green in the color.\n"
20112 "\n"
20113 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20114 " degree of blue in the color.\n"
20115 "\n"
20116 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20117 " (0.0-1.0).\n"
20118 "\n"
20119 ""},
20120 { "plscolbg", _wrap_plscolbg, METH_VARARGS, "\n"
20121 "Set the background color by 8-bit RGB value\n"
20122 "\n"
20123 "DESCRIPTION:\n"
20124 "\n"
20125 " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
20126 " the PLplot documentation).\n"
20127 "\n"
20128 " Redacted form: plscolbg(r, g, b)\n"
20129 "\n"
20130 " This function is used in examples 15 and 31.\n"
20131 "\n"
20132 "\n"
20133 "\n"
20134 "SYNOPSIS:\n"
20135 "\n"
20136 "plscolbg(r, g, b)\n"
20137 "\n"
20138 "ARGUMENTS:\n"
20139 "\n"
20140 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20141 " degree of red in the color.\n"
20142 "\n"
20143 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20144 " degree of green in the color.\n"
20145 "\n"
20146 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20147 " degree of blue in the color.\n"
20148 "\n"
20149 ""},
20150 { "plscolbga", _wrap_plscolbga, METH_VARARGS, "\n"
20151 "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
20152 "\n"
20153 "DESCRIPTION:\n"
20154 "\n"
20155 " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
20156 " PLFLT alpha transparency value (see the PLplot documentation).\n"
20157 "\n"
20158 " This function is used in example 31.\n"
20159 "\n"
20160 "\n"
20161 "\n"
20162 "SYNOPSIS:\n"
20163 "\n"
20164 "plscolbga(r, g, b, alpha)\n"
20165 "\n"
20166 "ARGUMENTS:\n"
20167 "\n"
20168 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20169 " degree of red in the color.\n"
20170 "\n"
20171 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20172 " degree of green in the color.\n"
20173 "\n"
20174 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20175 " degree of blue in the color.\n"
20176 "\n"
20177 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20178 " (0.0-1.0).\n"
20179 "\n"
20180 ""},
20181 { "plscolor", _wrap_plscolor, METH_O, "\n"
20182 "Used to globally turn color output on/off\n"
20183 "\n"
20184 "DESCRIPTION:\n"
20185 "\n"
20186 " Used to globally turn color output on/off for those drivers/devices\n"
20187 " that support it.\n"
20188 "\n"
20189 " Redacted form: plscolor(color)\n"
20190 "\n"
20191 " This function is used in example 31.\n"
20192 "\n"
20193 "\n"
20194 "\n"
20195 "SYNOPSIS:\n"
20196 "\n"
20197 "plscolor(color)\n"
20198 "\n"
20199 "ARGUMENTS:\n"
20200 "\n"
20201 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
20202 " turned off. If non-zero, color is turned on.\n"
20203 "\n"
20204 ""},
20205 { "plscompression", _wrap_plscompression, METH_O, "\n"
20206 "Set device-compression level\n"
20207 "\n"
20208 "DESCRIPTION:\n"
20209 "\n"
20210 " Set device-compression level. Only used for drivers that provide\n"
20211 " compression. This function, if used, should be invoked before a call\n"
20212 " to plinit.\n"
20213 "\n"
20214 " Redacted form: plscompression(compression)\n"
20215 "\n"
20216 " This function is used in example 31.\n"
20217 "\n"
20218 "\n"
20219 "\n"
20220 "SYNOPSIS:\n"
20221 "\n"
20222 "plscompression(compression)\n"
20223 "\n"
20224 "ARGUMENTS:\n"
20225 "\n"
20226 " compression (PLINT, input) : The desired compression level. This is\n"
20227 " a device-dependent value. Currently only the jpeg and png devices\n"
20228 " use these values. For jpeg value is the jpeg quality which should\n"
20229 " normally be in the range 0-95. Higher values denote higher quality\n"
20230 " and hence larger image sizes. For png values are in the range -1\n"
20231 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
20232 " A value of -1 denotes the default zlib compression level. Values\n"
20233 " in the range 10-99 are divided by 10 and then used as the zlib\n"
20234 " compression level. Higher compression levels correspond to greater\n"
20235 " compression and small file sizes at the expense of more\n"
20236 " computation.\n"
20237 "\n"
20238 ""},
20239 { "plsdev", _wrap_plsdev, METH_O, "\n"
20240 "Set the device (keyword) name\n"
20241 "\n"
20242 "DESCRIPTION:\n"
20243 "\n"
20244 " Set the device (keyword) name.\n"
20245 "\n"
20246 " Redacted form: plsdev(devname)\n"
20247 "\n"
20248 " This function is used in examples 1, 14, and 20.\n"
20249 "\n"
20250 "\n"
20251 "\n"
20252 "SYNOPSIS:\n"
20253 "\n"
20254 "plsdev(devname)\n"
20255 "\n"
20256 "ARGUMENTS:\n"
20257 "\n"
20258 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20259 " containing the device name keyword of the required output device.\n"
20260 " If\n"
20261 " devname is NULL or if the first character of the string is a ``?'',\n"
20262 " the normal (prompted) start up is used.\n"
20263 "\n"
20264 ""},
20265 { "plsdidev", _wrap_plsdidev, METH_VARARGS, "\n"
20266 "Set parameters that define current device-space window\n"
20267 "\n"
20268 "DESCRIPTION:\n"
20269 "\n"
20270 " Set relative margin width, aspect ratio, and relative justification\n"
20271 " that define current device-space window. If you want to just use the\n"
20272 " previous value for any of these, just pass in the magic value\n"
20273 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
20274 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
20275 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
20276 " to a device-specific value.\n"
20277 "\n"
20278 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20279 "\n"
20280 " This function is used in example 31.\n"
20281 "\n"
20282 "\n"
20283 "\n"
20284 "SYNOPSIS:\n"
20285 "\n"
20286 "plsdidev(mar, aspect, jx, jy)\n"
20287 "\n"
20288 "ARGUMENTS:\n"
20289 "\n"
20290 " mar (PLFLT, input) : Relative margin width.\n"
20291 "\n"
20292 " aspect (PLFLT, input) : Aspect ratio.\n"
20293 "\n"
20294 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20295 " the range -0.5 to 0.5.\n"
20296 "\n"
20297 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20298 " the range -0.5 to 0.5.\n"
20299 "\n"
20300 ""},
20301 { "plsdimap", _wrap_plsdimap, METH_VARARGS, "\n"
20302 "Set up transformation from metafile coordinates\n"
20303 "\n"
20304 "DESCRIPTION:\n"
20305 "\n"
20306 " Set up transformation from metafile coordinates. The size of the plot\n"
20307 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20308 " general-purpose facility just yet (not sure why the user would need\n"
20309 " it, for one).\n"
20310 "\n"
20311 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20312 " dimypmm)\n"
20313 "\n"
20314 " This function is not used in any examples.\n"
20315 "\n"
20316 "\n"
20317 "\n"
20318 "SYNOPSIS:\n"
20319 "\n"
20320 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20321 "\n"
20322 "ARGUMENTS:\n"
20323 "\n"
20324 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
20325 "\n"
20326 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
20327 "\n"
20328 " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
20329 "\n"
20330 " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
20331 "\n"
20332 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20333 "\n"
20334 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20335 "\n"
20336 ""},
20337 { "plsdiori", _wrap_plsdiori, METH_O, "\n"
20338 "Set plot orientation\n"
20339 "\n"
20340 "DESCRIPTION:\n"
20341 "\n"
20342 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20343 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20344 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20345 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20346 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20347 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20348 " not called the default value of rot is 0.\n"
20349 "\n"
20350 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20351 " probably want to change the aspect ratio to a value suitable for the\n"
20352 " plot orientation using a call to plsdidev or the command-line options\n"
20353 " -a or -freeaspect. For more documentation of those options see the\n"
20354 " PLplot documentation. Such command-line options can be set internally\n"
20355 " using plsetopt or set directly using the command line and parsed using\n"
20356 " a call to plparseopts.\n"
20357 "\n"
20358 " Redacted form: plsdiori(rot)\n"
20359 "\n"
20360 " This function is not used in any examples.\n"
20361 "\n"
20362 "\n"
20363 "\n"
20364 "SYNOPSIS:\n"
20365 "\n"
20366 "plsdiori(rot)\n"
20367 "\n"
20368 "ARGUMENTS:\n"
20369 "\n"
20370 " rot (PLFLT, input) : Plot orientation parameter.\n"
20371 "\n"
20372 ""},
20373 { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, "\n"
20374 "Set parameters that define current plot-space window\n"
20375 "\n"
20376 "DESCRIPTION:\n"
20377 "\n"
20378 " Set relative minima and maxima that define the current plot-space\n"
20379 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20380 " xmax, and ymax are 0., 0., 1., and 1.\n"
20381 "\n"
20382 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20383 "\n"
20384 " This function is used in example 31.\n"
20385 "\n"
20386 "\n"
20387 "\n"
20388 "SYNOPSIS:\n"
20389 "\n"
20390 "plsdiplt(xmin, ymin, xmax, ymax)\n"
20391 "\n"
20392 "ARGUMENTS:\n"
20393 "\n"
20394 " xmin (PLFLT, input) : Relative minimum in x.\n"
20395 "\n"
20396 " ymin (PLFLT, input) : Relative minimum in y.\n"
20397 "\n"
20398 " xmax (PLFLT, input) : Relative maximum in x.\n"
20399 "\n"
20400 " ymax (PLFLT, input) : Relative maximum in y.\n"
20401 "\n"
20402 ""},
20403 { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, "\n"
20404 "Set parameters incrementally (zoom mode) that define current plot-space window\n"
20405 "\n"
20406 "DESCRIPTION:\n"
20407 "\n"
20408 " Set relative minima and maxima incrementally (zoom mode) that define\n"
20409 " the current plot-space window. This function has the same effect as\n"
20410 " plsdiplt if that function has not been previously called. Otherwise,\n"
20411 " this function implements zoom mode using the transformation min_used =\n"
20412 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20413 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20414 " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20415 "\n"
20416 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20417 "\n"
20418 " This function is used in example 31.\n"
20419 "\n"
20420 "\n"
20421 "\n"
20422 "SYNOPSIS:\n"
20423 "\n"
20424 "plsdiplz(xmin, ymin, xmax, ymax)\n"
20425 "\n"
20426 "ARGUMENTS:\n"
20427 "\n"
20428 " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20429 "\n"
20430 " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20431 "\n"
20432 " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20433 "\n"
20434 " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20435 "\n"
20436 ""},
20437 { "plseed", _wrap_plseed, METH_O, "\n"
20438 "Set seed for internal random number generator.\n"
20439 "\n"
20440 "DESCRIPTION:\n"
20441 "\n"
20442 " Set the seed for the internal random number generator. See plrandd for\n"
20443 " further details.\n"
20444 "\n"
20445 " Redacted form: plseed(seed)\n"
20446 "\n"
20447 " This function is used in example 21.\n"
20448 "\n"
20449 "\n"
20450 "\n"
20451 "SYNOPSIS:\n"
20452 "\n"
20453 "plseed(seed)\n"
20454 "\n"
20455 "ARGUMENTS:\n"
20456 "\n"
20457 " seed (unsigned int, input) : Seed for random number generator.\n"
20458 "\n"
20459 ""},
20460 { "plsesc", _wrap_plsesc, METH_O, "\n"
20461 "Set the escape character for text strings\n"
20462 "\n"
20463 "DESCRIPTION:\n"
20464 "\n"
20465 " Set the escape character for text strings. From C (in contrast to\n"
20466 " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
20467 " characters are allowed to prevent the user from shooting himself in\n"
20468 " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
20469 " use of backslash as a character escape). Here are the allowed escape\n"
20470 " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
20471 " #, ASCII 35\n"
20472 " $, ASCII 36\n"
20473 " %, ASCII 37\n"
20474 " &, ASCII 38\n"
20475 " *, ASCII 42\n"
20476 " @, ASCII 64\n"
20477 " ^, ASCII 94\n"
20478 " ~, ASCII 126\n"
20479 "\n"
20480 "\n"
20481 " Redacted form: General: plsesc(esc)\n"
20482 "\n"
20483 "\n"
20484 " This function is used in example 29.\n"
20485 "\n"
20486 "\n"
20487 "\n"
20488 "SYNOPSIS:\n"
20489 "\n"
20490 "plsesc(esc)\n"
20491 "\n"
20492 "ARGUMENTS:\n"
20493 "\n"
20494 " esc (char, input) : Escape character.\n"
20495 "\n"
20496 ""},
20497 { "plsetopt", _wrap_plsetopt, METH_VARARGS, "\n"
20498 "Set any command-line option\n"
20499 "\n"
20500 "DESCRIPTION:\n"
20501 "\n"
20502 " Set any command-line option internally from a program before it\n"
20503 " invokes plinit. opt is the name of the command-line option and optarg\n"
20504 " is the corresponding command-line option argument.\n"
20505 "\n"
20506 " This function returns 0 on success.\n"
20507 "\n"
20508 " Redacted form: plsetopt(opt, optarg)\n"
20509 "\n"
20510 " This function is used in example 14.\n"
20511 "\n"
20512 "\n"
20513 "\n"
20514 "SYNOPSIS:\n"
20515 "\n"
20516 "PLINT plsetopt(opt, optarg)\n"
20517 "\n"
20518 "ARGUMENTS:\n"
20519 "\n"
20520 " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20521 " the command-line option.\n"
20522 "\n"
20523 " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20524 " containing the argument of the command-line option.\n"
20525 "\n"
20526 ""},
20527 { "plsfam", _wrap_plsfam, METH_VARARGS, "\n"
20528 "Set family file parameters\n"
20529 "\n"
20530 "DESCRIPTION:\n"
20531 "\n"
20532 " Sets variables dealing with output file familying. Does nothing if\n"
20533 " familying not supported by the driver. This routine, if used, must be\n"
20534 " called before initializing PLplot. See the PLplot documentation for\n"
20535 " more information.\n"
20536 "\n"
20537 " Redacted form: plsfam(fam, num, bmax)\n"
20538 "\n"
20539 " This function is used in examples 14 and 31.\n"
20540 "\n"
20541 "\n"
20542 "\n"
20543 "SYNOPSIS:\n"
20544 "\n"
20545 "plsfam(fam, num, bmax)\n"
20546 "\n"
20547 "ARGUMENTS:\n"
20548 "\n"
20549 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20550 " is enabled.\n"
20551 "\n"
20552 " num (PLINT, input) : Current family file number.\n"
20553 "\n"
20554 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20555 " file.\n"
20556 "\n"
20557 ""},
20558 { "plsfci", _wrap_plsfci, METH_O, "\n"
20559 "Set FCI (font characterization integer)\n"
20560 "\n"
20561 "DESCRIPTION:\n"
20562 "\n"
20563 " Sets font characteristics to be used at the start of the next string\n"
20564 " using the FCI approach. See the PLplot documentation for more\n"
20565 " information. Note, plsfont (which calls plsfci internally) provides a\n"
20566 " more user-friendly API for setting the font characterisitics.\n"
20567 "\n"
20568 " Redacted form: General: plsfci(fci)\n"
20569 "\n"
20570 "\n"
20571 " This function is used in example 23.\n"
20572 "\n"
20573 "\n"
20574 "\n"
20575 "SYNOPSIS:\n"
20576 "\n"
20577 "plsfci(fci)\n"
20578 "\n"
20579 "ARGUMENTS:\n"
20580 "\n"
20581 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20582 " of FCI.\n"
20583 "\n"
20584 ""},
20585 { "plsfnam", _wrap_plsfnam, METH_O, "\n"
20586 "Set output file name\n"
20587 "\n"
20588 "DESCRIPTION:\n"
20589 "\n"
20590 " Sets the current output file name, if applicable. If the file name\n"
20591 " has not been specified and is required by the driver, the user will be\n"
20592 " prompted for it. If using the X-windows output driver, this sets the\n"
20593 " display name. This routine, if used, must be called before\n"
20594 " initializing PLplot.\n"
20595 "\n"
20596 " Redacted form: plsfnam(fnam)\n"
20597 "\n"
20598 " This function is used in examples 1 and 20.\n"
20599 "\n"
20600 "\n"
20601 "\n"
20602 "SYNOPSIS:\n"
20603 "\n"
20604 "plsfnam(fnam)\n"
20605 "\n"
20606 "ARGUMENTS:\n"
20607 "\n"
20608 " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20609 " the file name.\n"
20610 "\n"
20611 ""},
20612 { "plsfont", _wrap_plsfont, METH_VARARGS, "\n"
20613 "Set family, style and weight of the current font\n"
20614 "\n"
20615 "DESCRIPTION:\n"
20616 "\n"
20617 " Sets the current font. See the PLplot documentation for more\n"
20618 " information on font selection.\n"
20619 "\n"
20620 " Redacted form: plsfont(family, style, weight)\n"
20621 "\n"
20622 " This function is used in example 23.\n"
20623 "\n"
20624 "\n"
20625 "\n"
20626 "SYNOPSIS:\n"
20627 "\n"
20628 "plsfont(family, style, weight)\n"
20629 "\n"
20630 "ARGUMENTS:\n"
20631 "\n"
20632 " family (PLINT, input) : Font family to select for the current font.\n"
20633 " The available values are given by the PL_FCI_* constants in\n"
20634 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20635 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20636 " signifies that the font family should not be altered.\n"
20637 "\n"
20638 " style (PLINT, input) : Font style to select for the current font.\n"
20639 " The available values are given by the PL_FCI_* constants in\n"
20640 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20641 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20642 " should not be altered.\n"
20643 "\n"
20644 " weight (PLINT, input) : Font weight to select for the current font.\n"
20645 " The available values are given by the PL_FCI_* constants in\n"
20646 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20647 " negative value signifies that the font weight should not be\n"
20648 " altered.\n"
20649 "\n"
20650 ""},
20651 { "plshades", _wrap_plshades, METH_VARARGS, "\n"
20652 "Shade regions on the basis of value\n"
20653 "\n"
20654 "DESCRIPTION:\n"
20655 "\n"
20656 " Shade regions on the basis of value. This is the high-level routine\n"
20657 " for making continuous color shaded plots with cmap1 while plshade\n"
20658 " should be used to plot individual shaded regions using either cmap0 or\n"
20659 " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20660 " our supported languages.\n"
20661 "\n"
20662 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20663 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20664 " pltr_data)\n"
20665 "\n"
20666 "\n"
20667 " This function is used in examples 16, 21, and 22.\n"
20668 "\n"
20669 "\n"
20670 "\n"
20671 "SYNOPSIS:\n"
20672 "\n"
20673 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20674 "\n"
20675 "ARGUMENTS:\n"
20676 "\n"
20677 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20678 " plot. Should have dimensions of\n"
20679 " nx by\n"
20680 " ny.\n"
20681 "\n"
20682 " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20683 "\n"
20684 " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20685 "\n"
20686 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20687 " the region that should be plotted in the shade plot. This\n"
20688 " function accepts x and y coordinates as input arguments and must\n"
20689 " return 1 if the point is to be included in the shade plot and 0\n"
20690 " otherwise. If you want to plot the entire shade plot (the usual\n"
20691 " case), this argument should be set to NULL.\n"
20692 "\n"
20693 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20694 " pltr below for how these arguments are used (only for the special case\n"
20695 " when the callback function\n"
20696 " pltr is not supplied).\n"
20697 "\n"
20698 " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20699 " corresponding to the edges of each shaded region that will be\n"
20700 " plotted by this function. To work properly the levels should be\n"
20701 " monotonic.\n"
20702 "\n"
20703 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20704 " of shade edge values in clevel).\n"
20705 "\n"
20706 " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20707 " pattern.\n"
20708 "\n"
20709 " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20710 " contours defining edges of shaded regions. The pen color is only\n"
20711 " temporary set for the contour drawing. Set this value to zero or\n"
20712 " less if no shade edge contours are wanted.\n"
20713 "\n"
20714 " cont_width (PLFLT, input) : Defines line width used for contours\n"
20715 " defining edges of shaded regions. This value may not be honored\n"
20716 " by all drivers. The pen width is only temporary set for the\n"
20717 " contour drawing. Set this value to zero or less if no shade edge\n"
20718 " contours are wanted.\n"
20719 "\n"
20720 " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20721 " region. Use plfill for this purpose.\n"
20722 "\n"
20723 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20724 " map to rectangles after coordinate transformation with pltrl.\n"
20725 " Otherwise, set rectangular to false. If rectangular is set to\n"
20726 " true, plshade tries to save time by filling large rectangles.\n"
20727 " This optimization fails if the coordinate transformation distorts\n"
20728 " the shape of rectangles. For example a plot in polar coordinates\n"
20729 " has to have rectangular set to false.\n"
20730 "\n"
20731 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20732 " defines the transformation between the zero-based indices of the\n"
20733 " matrix a and world coordinates. If\n"
20734 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20735 " indices of a are mapped to the range\n"
20736 " xmin through\n"
20737 " xmax and the y indices of a are mapped to the range\n"
20738 " ymin through\n"
20739 " ymax.For the C case, transformation functions are provided in the\n"
20740 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20741 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20742 " matrices. In addition, C callback routines for the transformation\n"
20743 " can be supplied by the user such as the mypltr function in\n"
20744 " examples/c/x09c.c which provides a general linear transformation\n"
20745 " between index coordinates and world coordinates.For languages\n"
20746 " other than C you should consult the PLplot documentation for the\n"
20747 " details concerning how PLTRANSFORM_callback arguments are\n"
20748 " interfaced. However, in general, a particular pattern of\n"
20749 " callback-associated arguments such as a tr vector with 6 elements;\n"
20750 " xg and yg vectors; or xg and yg matrices are respectively\n"
20751 " interfaced to a linear-transformation routine similar to the above\n"
20752 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20753 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20754 " support native language callbacks for handling index to\n"
20755 " world-coordinate transformations. Examples of these various\n"
20756 " approaches are given in examples/<language>x09*,\n"
20757 " examples/<language>x16*, examples/<language>x20*,\n"
20758 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20759 " supported languages.\n"
20760 "\n"
20761 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20762 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20763 " externally supplied.\n"
20764 "\n"
20765 ""},
20766 { "plshade", _wrap_plshade, METH_VARARGS, "\n"
20767 "Shade individual region on the basis of value\n"
20768 "\n"
20769 "DESCRIPTION:\n"
20770 "\n"
20771 " Shade individual region on the basis of value. Use plshades if you\n"
20772 " want to shade a number of contiguous regions using continuous colors.\n"
20773 " In particular the edge contours are treated properly in plshades. If\n"
20774 " you attempt to do contiguous regions with plshade the contours at the\n"
20775 " edge of the shade are partially obliterated by subsequent plots of\n"
20776 " contiguous shaded regions.\n"
20777 "\n"
20778 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20779 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20780 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20781 "\n"
20782 "\n"
20783 " This function is used in example 15.\n"
20784 "\n"
20785 "\n"
20786 "\n"
20787 "SYNOPSIS:\n"
20788 "\n"
20789 "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"
20790 "\n"
20791 "ARGUMENTS:\n"
20792 "\n"
20793 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20794 " plot. Should have dimensions of\n"
20795 " nx by\n"
20796 " ny.\n"
20797 "\n"
20798 " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20799 "\n"
20800 " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20801 "\n"
20802 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20803 " the region that should be plotted in the shade plot. This\n"
20804 " function accepts x and y coordinates as input arguments and must\n"
20805 " return 1 if the point is to be included in the shade plot and 0\n"
20806 " otherwise. If you want to plot the entire shade plot (the usual\n"
20807 " case), this argument should be set to NULL.\n"
20808 "\n"
20809 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20810 " pltr below for how these arguments are used (only for the special case\n"
20811 " when the callback function\n"
20812 " pltr is not supplied).\n"
20813 "\n"
20814 " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20815 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20816 "\n"
20817 " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20818 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20819 "\n"
20820 " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20821 " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20822 " then sh_color is interpreted as a cmap1 argument in the range\n"
20823 " (0.0-1.0).\n"
20824 "\n"
20825 " sh_color (PLFLT, input) : Defines color map index with integer\n"
20826 " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20827 "\n"
20828 " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20829 "\n"
20830 " min_color (PLINT, input) : Defines pen color, width used by the\n"
20831 " boundary of shaded region. The min values are used for the\n"
20832 " shade_min boundary, and the max values are used on the shade_max\n"
20833 " boundary. Set color and width to zero for no plotted boundaries.\n"
20834 "\n"
20835 " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20836 " boundary of shaded region. The min values are used for the\n"
20837 " shade_min boundary, and the max values are used on the shade_max\n"
20838 " boundary. Set color and width to zero for no plotted boundaries.\n"
20839 "\n"
20840 " max_color (PLINT, input) : Defines pen color, width used by the\n"
20841 " boundary of shaded region. The min values are used for the\n"
20842 " shade_min boundary, and the max values are used on the shade_max\n"
20843 " boundary. Set color and width to zero for no plotted boundaries.\n"
20844 "\n"
20845 " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20846 " boundary of shaded region. The min values are used for the\n"
20847 " shade_min boundary, and the max values are used on the shade_max\n"
20848 " boundary. Set color and width to zero for no plotted boundaries.\n"
20849 "\n"
20850 " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20851 " Use plfill. Future version of PLplot may have other fill\n"
20852 " routines.\n"
20853 "\n"
20854 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20855 " map to rectangles after coordinate transformation with pltrl.\n"
20856 " Otherwise, set rectangular to false. If rectangular is set to\n"
20857 " true, plshade tries to save time by filling large rectangles.\n"
20858 " This optimization fails if the coordinate transformation distorts\n"
20859 " the shape of rectangles. For example a plot in polar coordinates\n"
20860 " has to have rectangular set to false.\n"
20861 "\n"
20862 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20863 " defines the transformation between the zero-based indices of the\n"
20864 " matrix a and world coordinates. If\n"
20865 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20866 " indices of a are mapped to the range\n"
20867 " xmin through\n"
20868 " xmax and the y indices of a are mapped to the range\n"
20869 " ymin through\n"
20870 " ymax.For the C case, transformation functions are provided in the\n"
20871 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20872 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20873 " matrices. In addition, C callback routines for the transformation\n"
20874 " can be supplied by the user such as the mypltr function in\n"
20875 " examples/c/x09c.c which provides a general linear transformation\n"
20876 " between index coordinates and world coordinates.For languages\n"
20877 " other than C you should consult the PLplot documentation for the\n"
20878 " details concerning how PLTRANSFORM_callback arguments are\n"
20879 " interfaced. However, in general, a particular pattern of\n"
20880 " callback-associated arguments such as a tr vector with 6 elements;\n"
20881 " xg and yg vectors; or xg and yg matrices are respectively\n"
20882 " interfaced to a linear-transformation routine similar to the above\n"
20883 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20884 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20885 " support native language callbacks for handling index to\n"
20886 " world-coordinate transformations. Examples of these various\n"
20887 " approaches are given in examples/<language>x09*,\n"
20888 " examples/<language>x16*, examples/<language>x20*,\n"
20889 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20890 " supported languages.\n"
20891 "\n"
20892 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20893 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20894 " externally supplied.\n"
20895 "\n"
20896 ""},
20897 { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, "\n"
20898 "Assign a function to use for generating custom axis labels\n"
20899 "\n"
20900 "DESCRIPTION:\n"
20901 "\n"
20902 " This function allows a user to provide their own function to provide\n"
20903 " axis label text. The user function is given the numeric value for a\n"
20904 " point on an axis and returns a string label to correspond with that\n"
20905 " value. Custom axis labels can be enabled by passing appropriate\n"
20906 " arguments to plenv, plbox, plbox3 and similar functions.\n"
20907 "\n"
20908 " This function is used in example 19.\n"
20909 "\n"
20910 "\n"
20911 "\n"
20912 "SYNOPSIS:\n"
20913 "\n"
20914 "plslabelfunc(label_func, label_data)\n"
20915 "\n"
20916 "ARGUMENTS:\n"
20917 "\n"
20918 " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20919 " label function. In order to reset to the default labelling, set\n"
20920 " this to NULL. The labelling function parameters are, in order:\n"
20921 " axis: This indicates which axis a label is being requested for.\n"
20922 " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20923 "\n"
20924 " value: This is the value along the axis which is being labelled.\n"
20925 "\n"
20926 " label_text: The string representation of the label value.\n"
20927 "\n"
20928 " length: The maximum length in characters allowed for label_text.\n"
20929 "\n"
20930 "\n"
20931 " label_data (PLPointer, input) : This parameter may be used to pass\n"
20932 " data to the label_func function.\n"
20933 "\n"
20934 ""},
20935 { "plsmaj", _wrap_plsmaj, METH_VARARGS, "\n"
20936 "Set length of major ticks\n"
20937 "\n"
20938 "DESCRIPTION:\n"
20939 "\n"
20940 " This sets up the length of the major ticks. The actual length is the\n"
20941 " product of the default length and a scaling factor as for character\n"
20942 " height.\n"
20943 "\n"
20944 " Redacted form: plsmaj(def, scale)\n"
20945 "\n"
20946 " This function is used in example 29.\n"
20947 "\n"
20948 "\n"
20949 "\n"
20950 "SYNOPSIS:\n"
20951 "\n"
20952 "plsmaj(def, scale)\n"
20953 "\n"
20954 "ARGUMENTS:\n"
20955 "\n"
20956 " def (PLFLT, input) : The default length of a major tick in\n"
20957 " millimeters, should be set to zero if the default length is to\n"
20958 " remain unchanged.\n"
20959 "\n"
20960 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
20961 " actual tick length.\n"
20962 "\n"
20963 ""},
20964 { "plsmem", _wrap_plsmem, METH_VARARGS, "\n"
20965 "Set the memory area to be plotted (RGB)\n"
20966 "\n"
20967 "DESCRIPTION:\n"
20968 "\n"
20969 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
20970 " the dev member of the stream structure. Also set the number of pixels\n"
20971 " in the memory passed in\n"
20972 " plotmem, which is a block of memory\n"
20973 " maxy by\n"
20974 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
20975 "\n"
20976 " This memory will have to be freed by the user!\n"
20977 "\n"
20978 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
20979 "\n"
20980 " This function is not used in any examples.\n"
20981 "\n"
20982 "\n"
20983 "\n"
20984 "SYNOPSIS:\n"
20985 "\n"
20986 "plsmem(maxx, maxy, plotmem)\n"
20987 "\n"
20988 "ARGUMENTS:\n"
20989 "\n"
20990 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
20991 "\n"
20992 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
20993 "\n"
20994 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
20995 " user-supplied writeable memory area.\n"
20996 "\n"
20997 ""},
20998 { "plsmema", _wrap_plsmema, METH_VARARGS, "\n"
20999 "Set the memory area to be plotted (RGBA)\n"
21000 "\n"
21001 "DESCRIPTION:\n"
21002 "\n"
21003 " Set the memory area to be plotted (with the memcairo driver) as the\n"
21004 " dev member of the stream structure. Also set the number of pixels in\n"
21005 " the memory passed in\n"
21006 " plotmem, which is a block of memory\n"
21007 " maxy by\n"
21008 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
21009 "\n"
21010 " This memory will have to be freed by the user!\n"
21011 "\n"
21012 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
21013 "\n"
21014 " This function is not used in any examples.\n"
21015 "\n"
21016 "\n"
21017 "\n"
21018 "SYNOPSIS:\n"
21019 "\n"
21020 "plsmema(maxx, maxy, plotmem)\n"
21021 "\n"
21022 "ARGUMENTS:\n"
21023 "\n"
21024 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21025 "\n"
21026 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21027 "\n"
21028 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21029 " user-supplied writeable memory area.\n"
21030 "\n"
21031 ""},
21032 { "plsmin", _wrap_plsmin, METH_VARARGS, "\n"
21033 "Set length of minor ticks\n"
21034 "\n"
21035 "DESCRIPTION:\n"
21036 "\n"
21037 " This sets up the length of the minor ticks and the length of the\n"
21038 " terminals on error bars. The actual length is the product of the\n"
21039 " default length and a scaling factor as for character height.\n"
21040 "\n"
21041 " Redacted form: plsmin(def, scale)\n"
21042 "\n"
21043 " This function is used in example 29.\n"
21044 "\n"
21045 "\n"
21046 "\n"
21047 "SYNOPSIS:\n"
21048 "\n"
21049 "plsmin(def, scale)\n"
21050 "\n"
21051 "ARGUMENTS:\n"
21052 "\n"
21053 " def (PLFLT, input) : The default length of a minor tick in\n"
21054 " millimeters, should be set to zero if the default length is to\n"
21055 " remain unchanged.\n"
21056 "\n"
21057 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21058 " actual tick length.\n"
21059 "\n"
21060 ""},
21061 { "plsori", _wrap_plsori, METH_O, "\n"
21062 "Set orientation\n"
21063 "\n"
21064 "DESCRIPTION:\n"
21065 "\n"
21066 " Set integer plot orientation parameter. This function is identical to\n"
21067 " plsdiori except for the type of the argument, and should be used in\n"
21068 " the same way. See the documentation of plsdiori for details.\n"
21069 "\n"
21070 " Redacted form: plsori(ori)\n"
21071 "\n"
21072 " This function is used in example 3.\n"
21073 "\n"
21074 "\n"
21075 "\n"
21076 "SYNOPSIS:\n"
21077 "\n"
21078 "plsori(ori)\n"
21079 "\n"
21080 "ARGUMENTS:\n"
21081 "\n"
21082 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
21083 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
21084 " angle.\n"
21085 "\n"
21086 ""},
21087 { "plspage", _wrap_plspage, METH_VARARGS, "\n"
21088 "Set page parameters\n"
21089 "\n"
21090 "DESCRIPTION:\n"
21091 "\n"
21092 " Sets the page configuration (optional). If an individual parameter is\n"
21093 " zero then that parameter value is not updated. Not all parameters are\n"
21094 " recognized by all drivers and the interpretation is device-dependent.\n"
21095 " The X-window driver uses the length and offset parameters to determine\n"
21096 " the window size and location. The length and offset values are\n"
21097 " expressed in units that are specific to the current driver. For\n"
21098 " instance: screen drivers will usually interpret them as number of\n"
21099 " pixels, whereas printer drivers will usually use mm.\n"
21100 "\n"
21101 " This routine, if used, must be called before initializing PLplot. It\n"
21102 " may be called at later times for interactive drivers to change only\n"
21103 " the dpi for subsequent redraws which you can force via a call to\n"
21104 " plreplot. If this function is not called then the page size defaults\n"
21105 " to landscape A4 for drivers which use real world page sizes and 744\n"
21106 " pixels wide by 538 pixels high for raster drivers. The default value\n"
21107 " for dx and dy is 90 pixels per inch for raster drivers.\n"
21108 "\n"
21109 "\n"
21110 "\n"
21111 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21112 "\n"
21113 " This function is used in examples 14 and 31.\n"
21114 "\n"
21115 "\n"
21116 "\n"
21117 "SYNOPSIS:\n"
21118 "\n"
21119 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21120 "\n"
21121 "ARGUMENTS:\n"
21122 "\n"
21123 " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
21124 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21125 " (e.g. mm).\n"
21126 "\n"
21127 " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
21128 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21129 " (e.g. mm).\n"
21130 "\n"
21131 " xleng (PLINT, input) : Page length, x.\n"
21132 "\n"
21133 " yleng (PLINT, input) : Page length, y.\n"
21134 "\n"
21135 " xoff (PLINT, input) : Page offset, x.\n"
21136 "\n"
21137 " yoff (PLINT, input) : Page offset, y.\n"
21138 "\n"
21139 ""},
21140 { "plspal0", _wrap_plspal0, METH_O, "\n"
21141 "Set the cmap0 palette using the specified cmap0*.pal format file\n"
21142 "\n"
21143 "DESCRIPTION:\n"
21144 "\n"
21145 " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
21146 "\n"
21147 " Redacted form: plspal0(filename)\n"
21148 "\n"
21149 " This function is in example 16.\n"
21150 "\n"
21151 "\n"
21152 "\n"
21153 "SYNOPSIS:\n"
21154 "\n"
21155 "plspal0(filename)\n"
21156 "\n"
21157 "ARGUMENTS:\n"
21158 "\n"
21159 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21160 " containing the name of the cmap0*.pal file. If this string is\n"
21161 " empty, use the default cmap0*.pal file.\n"
21162 "\n"
21163 ""},
21164 { "plspal1", _wrap_plspal1, METH_VARARGS, "\n"
21165 "Set the cmap1 palette using the specified cmap1*.pal format file\n"
21166 "\n"
21167 "DESCRIPTION:\n"
21168 "\n"
21169 " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
21170 "\n"
21171 " Redacted form: plspal1(filename, interpolate)\n"
21172 "\n"
21173 " This function is used in example 16.\n"
21174 "\n"
21175 "\n"
21176 "\n"
21177 "SYNOPSIS:\n"
21178 "\n"
21179 "plspal1(filename, interpolate)\n"
21180 "\n"
21181 "ARGUMENTS:\n"
21182 "\n"
21183 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21184 " containing the name of the cmap1*.pal file. If this string is\n"
21185 " empty, use the default cmap1*.pal file.\n"
21186 "\n"
21187 " interpolate (PLBOOL, input) : If this parameter is true, the\n"
21188 " columns containing the intensity index, r, g, b, alpha and\n"
21189 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
21190 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
21191 " a flag which controls whether the r, g, b data sent to plscmap1la\n"
21192 " are interpreted as HLS or RGB.) If this parameter is false, the\n"
21193 " intensity index and alt_hue_path columns are ignored and the r, g,\n"
21194 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
21195 " are used instead to set the cmap1 palette directly with a call to\n"
21196 " plscmap1a.\n"
21197 "\n"
21198 ""},
21199 { "plspause", _wrap_plspause, METH_O, "\n"
21200 "Set the pause (on end-of-page) status\n"
21201 "\n"
21202 "DESCRIPTION:\n"
21203 "\n"
21204 " Set the pause (on end-of-page) status.\n"
21205 "\n"
21206 " Redacted form: plspause(pause)\n"
21207 "\n"
21208 " This function is in examples 14,20.\n"
21209 "\n"
21210 "\n"
21211 "\n"
21212 "SYNOPSIS:\n"
21213 "\n"
21214 "plspause(pause)\n"
21215 "\n"
21216 "ARGUMENTS:\n"
21217 "\n"
21218 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
21219 " end-of-page for those drivers which support this. Otherwise there\n"
21220 " is no pause.\n"
21221 "\n"
21222 ""},
21223 { "plsstrm", _wrap_plsstrm, METH_O, "\n"
21224 "Set current output stream\n"
21225 "\n"
21226 "DESCRIPTION:\n"
21227 "\n"
21228 " Sets the number of the current output stream. The stream number\n"
21229 " defaults to 0 unless changed by this routine. The first use of this\n"
21230 " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
21231 "\n"
21232 " Redacted form: plsstrm(strm)\n"
21233 "\n"
21234 " This function is examples 1,14,20.\n"
21235 "\n"
21236 "\n"
21237 "\n"
21238 "SYNOPSIS:\n"
21239 "\n"
21240 "plsstrm(strm)\n"
21241 "\n"
21242 "ARGUMENTS:\n"
21243 "\n"
21244 " strm (PLINT, input) : The current stream number.\n"
21245 "\n"
21246 ""},
21247 { "plssub", _wrap_plssub, METH_VARARGS, "\n"
21248 "Set the number of subpages in x and y\n"
21249 "\n"
21250 "DESCRIPTION:\n"
21251 "\n"
21252 " Set the number of subpages in x and y.\n"
21253 "\n"
21254 " Redacted form: plssub(nx, ny)\n"
21255 "\n"
21256 " This function is examples 1,2,14,21,25,27.\n"
21257 "\n"
21258 "\n"
21259 "\n"
21260 "SYNOPSIS:\n"
21261 "\n"
21262 "plssub(nx, ny)\n"
21263 "\n"
21264 "ARGUMENTS:\n"
21265 "\n"
21266 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
21267 " of window columns).\n"
21268 "\n"
21269 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
21270 " of window rows).\n"
21271 "\n"
21272 ""},
21273 { "plssym", _wrap_plssym, METH_VARARGS, "\n"
21274 "Set symbol size\n"
21275 "\n"
21276 "DESCRIPTION:\n"
21277 "\n"
21278 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
21279 " plsym. The actual height of a symbol is the product of the default\n"
21280 " symbol size and a scaling factor as for the character height.\n"
21281 "\n"
21282 " Redacted form: plssym(def, scale)\n"
21283 "\n"
21284 " This function is used in example 29.\n"
21285 "\n"
21286 "\n"
21287 "\n"
21288 "SYNOPSIS:\n"
21289 "\n"
21290 "plssym(def, scale)\n"
21291 "\n"
21292 "ARGUMENTS:\n"
21293 "\n"
21294 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
21295 " should be set to zero if the default height is to remain\n"
21296 " unchanged.\n"
21297 "\n"
21298 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21299 " actual symbol height.\n"
21300 "\n"
21301 ""},
21302 { "plstar", _wrap_plstar, METH_VARARGS, "\n"
21303 "Initialization\n"
21304 "\n"
21305 "DESCRIPTION:\n"
21306 "\n"
21307 " Initializing the plotting package. The program prompts for the device\n"
21308 " keyword or number of the desired output device. Hitting a RETURN in\n"
21309 " response to the prompt is the same as selecting the first device. If\n"
21310 " only one device is enabled when PLplot is installed, plstar will issue\n"
21311 " no prompt. The output device is divided into nx by ny subpages, each\n"
21312 " of which may be used independently. The subroutine pladv is used to\n"
21313 " advance from one subpage to the next.\n"
21314 "\n"
21315 " Redacted form: plstar(nx, ny)\n"
21316 "\n"
21317 " This function is used in example 1.\n"
21318 "\n"
21319 "\n"
21320 "\n"
21321 "SYNOPSIS:\n"
21322 "\n"
21323 "plstar(nx, ny)\n"
21324 "\n"
21325 "ARGUMENTS:\n"
21326 "\n"
21327 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21328 " x direction.\n"
21329 "\n"
21330 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21331 " y direction.\n"
21332 "\n"
21333 ""},
21334 { "plstart", _wrap_plstart, METH_VARARGS, "\n"
21335 "Initialization\n"
21336 "\n"
21337 "DESCRIPTION:\n"
21338 "\n"
21339 " Alternative to plstar for initializing the plotting package. The\n"
21340 " device name keyword for the desired output device must be supplied as\n"
21341 " an argument. These keywords are the same as those printed out by\n"
21342 " plstar. If the requested device is not available, or if the input\n"
21343 " string is empty or begins with ``?'', the prompted start up of plstar\n"
21344 " is used. This routine also divides the output device page into nx by\n"
21345 " ny subpages, each of which may be used independently. The subroutine\n"
21346 " pladv is used to advance from one subpage to the next.\n"
21347 "\n"
21348 " Redacted form: General: plstart(devname, nx, ny)\n"
21349 "\n"
21350 "\n"
21351 " This function is not used in any examples.\n"
21352 "\n"
21353 "\n"
21354 "\n"
21355 "SYNOPSIS:\n"
21356 "\n"
21357 "plstart(devname, nx, ny)\n"
21358 "\n"
21359 "ARGUMENTS:\n"
21360 "\n"
21361 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
21362 " containing the device name keyword of the required output device.\n"
21363 " If\n"
21364 " devname is NULL or if the first character of the string is a ``?'',\n"
21365 " the normal (prompted) start up is used.\n"
21366 "\n"
21367 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21368 " x direction.\n"
21369 "\n"
21370 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21371 " y direction.\n"
21372 "\n"
21373 ""},
21374 { "plstransform", _wrap_plstransform, METH_VARARGS, "\n"
21375 "Set a global coordinate transform function\n"
21376 "\n"
21377 "DESCRIPTION:\n"
21378 "\n"
21379 " This function can be used to define a coordinate transformation which\n"
21380 " affects all elements drawn within the current plot window. The\n"
21381 " coordinate_transform callback function is similar to that provided for\n"
21382 " the plmap and plmeridians functions. The coordinate_transform_data\n"
21383 " parameter may be used to pass extra data to coordinate_transform.\n"
21384 "\n"
21385 " Redacted form: General: plstransform(coordinate_transform,\n"
21386 " coordinate_transform_data)\n"
21387 "\n"
21388 "\n"
21389 " This function is used in examples 19 and 22.\n"
21390 "\n"
21391 "\n"
21392 "\n"
21393 "SYNOPSIS:\n"
21394 "\n"
21395 "plstransform(coordinate_transform, coordinate_transform_data)\n"
21396 "\n"
21397 "ARGUMENTS:\n"
21398 "\n"
21399 " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
21400 " function that defines the transformation from the input (x, y)\n"
21401 " world coordinates to new PLplot world coordinates. If\n"
21402 " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
21403 " case), then no transform is applied.\n"
21404 "\n"
21405 " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
21406 " for\n"
21407 " coordinate_transform.\n"
21408 "\n"
21409 ""},
21410 { "plstring", _wrap_plstring, METH_VARARGS, "\n"
21411 "Plot a glyph at the specified points\n"
21412 "\n"
21413 "DESCRIPTION:\n"
21414 "\n"
21415 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21416 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21417 " is specified with a PLplot user string. Note that the user string is\n"
21418 " not actually limited to one glyph so it is possible (but not normally\n"
21419 " useful) to plot more than one glyph at the specified points with this\n"
21420 " function. As with plmtex and plptex, the user string can contain FCI\n"
21421 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21422 " else PLplot escapes for Hershey or unicode text to determine the\n"
21423 " glyph.\n"
21424 "\n"
21425 " Redacted form: plstring(x, y, string)\n"
21426 "\n"
21427 " This function is used in examples 4, 21 and 26.\n"
21428 "\n"
21429 "\n"
21430 "\n"
21431 "SYNOPSIS:\n"
21432 "\n"
21433 "plstring(n, x, y, string)\n"
21434 "\n"
21435 "ARGUMENTS:\n"
21436 "\n"
21437 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21438 "\n"
21439 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21440 " the points.\n"
21441 "\n"
21442 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21443 " the points.\n"
21444 "\n"
21445 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21446 " the glyph(s) to be plotted at each of the n points.\n"
21447 "\n"
21448 ""},
21449 { "plstring3", _wrap_plstring3, METH_VARARGS, "\n"
21450 "Plot a glyph at the specified 3D points\n"
21451 "\n"
21452 "DESCRIPTION:\n"
21453 "\n"
21454 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21455 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21456 " this function similar to what is done for plline3. The glyph is\n"
21457 " specified with a PLplot user string. Note that the user string is not\n"
21458 " actually limited to one glyph so it is possible (but not normally\n"
21459 " useful) to plot more than one glyph at the specified points with this\n"
21460 " function. As with plmtex and plptex, the user string can contain FCI\n"
21461 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21462 " else PLplot escapes for Hershey or unicode text to determine the\n"
21463 " glyph.\n"
21464 "\n"
21465 " Redacted form: plstring3(x, y, z, string)\n"
21466 "\n"
21467 " This function is used in example 18.\n"
21468 "\n"
21469 "\n"
21470 "\n"
21471 "SYNOPSIS:\n"
21472 "\n"
21473 "plstring3(n, x, y, z, string)\n"
21474 "\n"
21475 "ARGUMENTS:\n"
21476 "\n"
21477 " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21478 "\n"
21479 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21480 " the points.\n"
21481 "\n"
21482 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21483 " the points.\n"
21484 "\n"
21485 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21486 " the points.\n"
21487 "\n"
21488 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21489 " the glyph(s) to be plotted at each of the n points. points.\n"
21490 "\n"
21491 ""},
21492 { "plstripa", _wrap_plstripa, METH_VARARGS, "\n"
21493 "Add a point to a strip chart\n"
21494 "\n"
21495 "DESCRIPTION:\n"
21496 "\n"
21497 " Add a point to a given pen of a given strip chart. There is no need\n"
21498 " for all pens to have the same number of points or to be equally\n"
21499 " sampled in the x coordinate. Allocates memory and rescales as\n"
21500 " necessary.\n"
21501 "\n"
21502 " Redacted form: plstripa(id, pen, x, y)\n"
21503 "\n"
21504 " This function is used in example 17.\n"
21505 "\n"
21506 "\n"
21507 "\n"
21508 "SYNOPSIS:\n"
21509 "\n"
21510 "plstripa(id, pen, x, y)\n"
21511 "\n"
21512 "ARGUMENTS:\n"
21513 "\n"
21514 " id (PLINT, input) : Identification number of the strip chart (set\n"
21515 " up in plstripc).\n"
21516 "\n"
21517 " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21518 "\n"
21519 " x (PLFLT, input) : X coordinate of point to plot.\n"
21520 "\n"
21521 " y (PLFLT, input) : Y coordinate of point to plot.\n"
21522 "\n"
21523 ""},
21524 { "plstripc", _wrap_plstripc, METH_VARARGS, "\n"
21525 "Create a 4-pen strip chart\n"
21526 "\n"
21527 "DESCRIPTION:\n"
21528 "\n"
21529 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21530 "\n"
21531 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21532 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21533 " styline, legline, labx, laby, labz)\n"
21534 "\n"
21535 "\n"
21536 " This function is used in example 17.\n"
21537 "\n"
21538 "\n"
21539 "\n"
21540 "SYNOPSIS:\n"
21541 "\n"
21542 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21543 "\n"
21544 "ARGUMENTS:\n"
21545 "\n"
21546 " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21547 " number of the strip chart to use on plstripa and plstripd.\n"
21548 "\n"
21549 " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21550 " the x-axis specification as in plbox.\n"
21551 "\n"
21552 " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21553 " the y-axis specification as in plbox.\n"
21554 "\n"
21555 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21556 " change as data are added.\n"
21557 "\n"
21558 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21559 " change as data are added.\n"
21560 "\n"
21561 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21562 " is multiplied by the factor (1 +\n"
21563 " xjump) .\n"
21564 "\n"
21565 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21566 " change as data are added.\n"
21567 "\n"
21568 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21569 " change as data are added.\n"
21570 "\n"
21571 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21572 "\n"
21573 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21574 "\n"
21575 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21576 " true, otherwise not.\n"
21577 "\n"
21578 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21579 " otherwise slide display.\n"
21580 "\n"
21581 " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21582 "\n"
21583 " collab (PLINT, input) : Legend color index (cmap0).\n"
21584 "\n"
21585 " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21586 " indices for the 4 pens.\n"
21587 "\n"
21588 " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21589 " indices for the 4 pens.\n"
21590 "\n"
21591 " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21592 " strings containing legends for the 4 pens.\n"
21593 "\n"
21594 " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21595 " the label for the x axis.\n"
21596 "\n"
21597 " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21598 " the label for the y axis.\n"
21599 "\n"
21600 " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21601 " the plot title.\n"
21602 "\n"
21603 ""},
21604 { "plstripd", _wrap_plstripd, METH_O, "\n"
21605 "Deletes and releases memory used by a strip chart\n"
21606 "\n"
21607 "DESCRIPTION:\n"
21608 "\n"
21609 " Deletes and releases memory used by a strip chart.\n"
21610 "\n"
21611 " Redacted form: plstripd(id)\n"
21612 "\n"
21613 " This function is used in example 17.\n"
21614 "\n"
21615 "\n"
21616 "\n"
21617 "SYNOPSIS:\n"
21618 "\n"
21619 "plstripd(id)\n"
21620 "\n"
21621 "ARGUMENTS:\n"
21622 "\n"
21623 " id (PLINT, input) : Identification number of strip chart to delete.\n"
21624 "\n"
21625 ""},
21626 { "plstyl", _wrap_plstyl, METH_VARARGS, "\n"
21627 "Set line style\n"
21628 "\n"
21629 "DESCRIPTION:\n"
21630 "\n"
21631 " This sets up the line style for all lines subsequently drawn. A line\n"
21632 " consists of segments in which the pen is alternately down and up. The\n"
21633 " lengths of these segments are passed in the vectors mark and space\n"
21634 " respectively. The number of mark-space pairs is specified by nms. In\n"
21635 " order to return the line style to the default continuous line, plstyl\n"
21636 " should be called with nms =0 .(see also pllsty)\n"
21637 "\n"
21638 " Redacted form: plstyl(mark, space)\n"
21639 "\n"
21640 " This function is used in examples 1, 9, and 14.\n"
21641 "\n"
21642 "\n"
21643 "\n"
21644 "SYNOPSIS:\n"
21645 "\n"
21646 "plstyl(nms, mark, space)\n"
21647 "\n"
21648 "ARGUMENTS:\n"
21649 "\n"
21650 " nms (PLINT, input) : The number of mark and space elements in a\n"
21651 " line. Thus a simple broken line can be obtained by setting nms=1\n"
21652 " . A continuous line is specified by setting nms=0 .\n"
21653 "\n"
21654 " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21655 " segments during which the pen is down, measured in micrometers.\n"
21656 "\n"
21657 " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21658 " the segments during which the pen is up, measured in micrometers.\n"
21659 "\n"
21660 ""},
21661 { "plsvect", _wrap_plsvect, METH_VARARGS, "\n"
21662 "Set arrow style for vector plots\n"
21663 "\n"
21664 "DESCRIPTION:\n"
21665 "\n"
21666 " Set the style for the arrow used by plvect to plot vectors.\n"
21667 "\n"
21668 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21669 "\n"
21670 " This function is used in example 22.\n"
21671 "\n"
21672 "\n"
21673 "\n"
21674 "SYNOPSIS:\n"
21675 "\n"
21676 "plsvect(arrowx, arrowy, npts, fill)\n"
21677 "\n"
21678 "ARGUMENTS:\n"
21679 "\n"
21680 " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21681 " the x and y points which make up the arrow. The arrow is plotted\n"
21682 " by joining these points to form a polygon. The scaling assumes\n"
21683 " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21684 " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21685 " will be reset to its default.\n"
21686 "\n"
21687 " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21688 " arrowy.\n"
21689 "\n"
21690 " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21691 " fill is false then the arrow is open.\n"
21692 "\n"
21693 ""},
21694 { "plsvpa", _wrap_plsvpa, METH_VARARGS, "\n"
21695 "Specify viewport in absolute coordinates\n"
21696 "\n"
21697 "DESCRIPTION:\n"
21698 "\n"
21699 " Alternate routine to plvpor for setting up the viewport. This routine\n"
21700 " should be used only if the viewport is required to have a definite\n"
21701 " size in millimeters. The routine plgspa is useful for finding out the\n"
21702 " size of the current subpage.\n"
21703 "\n"
21704 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21705 "\n"
21706 " This function is used in example 10.\n"
21707 "\n"
21708 "\n"
21709 "\n"
21710 "SYNOPSIS:\n"
21711 "\n"
21712 "plsvpa(xmin, xmax, ymin, ymax)\n"
21713 "\n"
21714 "ARGUMENTS:\n"
21715 "\n"
21716 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21717 " viewport from the left-hand edge of the subpage in millimeters.\n"
21718 "\n"
21719 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21720 " viewport from the left-hand edge of the subpage in millimeters.\n"
21721 "\n"
21722 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21723 " viewport from the bottom edge of the subpage in millimeters.\n"
21724 "\n"
21725 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21726 " from the bottom edge of the subpage in millimeters.\n"
21727 "\n"
21728 ""},
21729 { "plsxax", _wrap_plsxax, METH_VARARGS, "\n"
21730 "Set x axis parameters\n"
21731 "\n"
21732 "DESCRIPTION:\n"
21733 "\n"
21734 " Sets values of the digmax and digits flags for the x axis. See the\n"
21735 " PLplot documentation for more information.\n"
21736 "\n"
21737 " Redacted form: plsxax(digmax, digits)\n"
21738 "\n"
21739 " This function is used in example 31.\n"
21740 "\n"
21741 "\n"
21742 "\n"
21743 "SYNOPSIS:\n"
21744 "\n"
21745 "plsxax(digmax, digits)\n"
21746 "\n"
21747 "ARGUMENTS:\n"
21748 "\n"
21749 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21750 " digits for the x axis. If nonzero, the printed label will be\n"
21751 " switched to a floating-point representation when the number of\n"
21752 " digits exceeds digmax.\n"
21753 "\n"
21754 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21755 " its value here has no effect since it is set only by plbox or\n"
21756 " plbox3. However, the user may obtain its value after a call to\n"
21757 " either of these functions by calling plgxax.\n"
21758 "\n"
21759 ""},
21760 { "plsyax", _wrap_plsyax, METH_VARARGS, "\n"
21761 "Set y axis parameters\n"
21762 "\n"
21763 "DESCRIPTION:\n"
21764 "\n"
21765 " Identical to plsxax, except that arguments are flags for y axis. See\n"
21766 " the description of plsxax for more detail.\n"
21767 "\n"
21768 " Redacted form: plsyax(digmax, digits)\n"
21769 "\n"
21770 " This function is used in examples 1, 14, and 31.\n"
21771 "\n"
21772 "\n"
21773 "\n"
21774 "SYNOPSIS:\n"
21775 "\n"
21776 "plsyax(digmax, digits)\n"
21777 "\n"
21778 "ARGUMENTS:\n"
21779 "\n"
21780 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21781 " digits for the y axis. If nonzero, the printed label will be\n"
21782 " switched to a floating-point representation when the number of\n"
21783 " digits exceeds digmax.\n"
21784 "\n"
21785 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21786 " its value here has no effect since it is set only by plbox or\n"
21787 " plbox3. However, the user may obtain its value after a call to\n"
21788 " either of these functions by calling plgyax.\n"
21789 "\n"
21790 ""},
21791 { "plsym", _wrap_plsym, METH_VARARGS, "\n"
21792 "Plot a glyph at the specified points\n"
21793 "\n"
21794 "DESCRIPTION:\n"
21795 "\n"
21796 " Plot a glyph at the specified points. (This function is largely\n"
21797 " superseded by plstring which gives access to many[!] more glyphs.)\n"
21798 "\n"
21799 " Redacted form: plsym(x, y, code)\n"
21800 "\n"
21801 " This function is used in example 7.\n"
21802 "\n"
21803 "\n"
21804 "\n"
21805 "SYNOPSIS:\n"
21806 "\n"
21807 "plsym(n, x, y, code)\n"
21808 "\n"
21809 "ARGUMENTS:\n"
21810 "\n"
21811 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21812 "\n"
21813 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21814 " the points.\n"
21815 "\n"
21816 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21817 " the points.\n"
21818 "\n"
21819 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21820 " to be plotted at each of the n points.\n"
21821 "\n"
21822 ""},
21823 { "plszax", _wrap_plszax, METH_VARARGS, "\n"
21824 "Set z axis parameters\n"
21825 "\n"
21826 "DESCRIPTION:\n"
21827 "\n"
21828 " Identical to plsxax, except that arguments are flags for z axis. See\n"
21829 " the description of plsxax for more detail.\n"
21830 "\n"
21831 " Redacted form: plszax(digmax, digits)\n"
21832 "\n"
21833 " This function is used in example 31.\n"
21834 "\n"
21835 "\n"
21836 "\n"
21837 "SYNOPSIS:\n"
21838 "\n"
21839 "plszax(digmax, digits)\n"
21840 "\n"
21841 "ARGUMENTS:\n"
21842 "\n"
21843 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21844 " digits for the z axis. If nonzero, the printed label will be\n"
21845 " switched to a floating-point representation when the number of\n"
21846 " digits exceeds digmax.\n"
21847 "\n"
21848 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21849 " its value here has no effect since it is set only by plbox or\n"
21850 " plbox3. However, the user may obtain its value after a call to\n"
21851 " either of these functions by calling plgzax.\n"
21852 "\n"
21853 ""},
21854 { "pltext", _wrap_pltext, METH_NOARGS, "\n"
21855 "Switch to text screen\n"
21856 "\n"
21857 "DESCRIPTION:\n"
21858 "\n"
21859 " Sets an interactive device to text mode, used in conjunction with\n"
21860 " plgra to allow graphics and text to be interspersed. On a device\n"
21861 " which supports separate text and graphics windows, this command causes\n"
21862 " control to be switched to the text window. This can be useful for\n"
21863 " printing diagnostic messages or getting user input, which would\n"
21864 " otherwise interfere with the plots. The program must switch back to\n"
21865 " the graphics window before issuing plot commands, as the text (or\n"
21866 " console) device will probably become quite confused otherwise. If\n"
21867 " already in text mode, this command is ignored. It is also ignored on\n"
21868 " devices which only support a single window or use a different method\n"
21869 " for shifting focus (see also plgra).\n"
21870 "\n"
21871 " Redacted form: pltext()\n"
21872 "\n"
21873 " This function is used in example 1.\n"
21874 "\n"
21875 "\n"
21876 "\n"
21877 "SYNOPSIS:\n"
21878 "\n"
21879 "pltext()\n"
21880 "\n"
21881 ""},
21882 { "pltimefmt", _wrap_pltimefmt, METH_O, "\n"
21883 "Set format for date / time labels\n"
21884 "\n"
21885 "DESCRIPTION:\n"
21886 "\n"
21887 " Sets the format for date / time labels. To enable date / time format\n"
21888 " labels see the options to plbox, plbox3, and plenv.\n"
21889 "\n"
21890 " Redacted form: pltimefmt(fmt)\n"
21891 "\n"
21892 " This function is used in example 29.\n"
21893 "\n"
21894 "\n"
21895 "\n"
21896 "SYNOPSIS:\n"
21897 "\n"
21898 "pltimefmt(fmt)\n"
21899 "\n"
21900 "ARGUMENTS:\n"
21901 "\n"
21902 " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21903 " interpreted similarly to the format specifier of typical system\n"
21904 " strftime routines except that PLplot ignores locale and also\n"
21905 " supplies some useful extensions in the context of plotting. All\n"
21906 " text in the string is printed as-is other than conversion\n"
21907 " specifications which take the form of a '%' character followed by\n"
21908 " further conversion specification character. The conversion\n"
21909 " specifications which are similar to those provided by system\n"
21910 " strftime routines are the following: %a: The abbreviated (English)\n"
21911 " weekday name.\n"
21912 " %A: The full (English) weekday name.\n"
21913 " %b: The abbreviated (English) month name.\n"
21914 " %B: The full (English) month name.\n"
21915 " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21916 " %C: The century number (year/100) as a 2-digit integer.\n"
21917 " %d: The day of the month as a decimal number (range 01 to 31).\n"
21918 " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21919 " %e: Like %d, but a leading zero is replaced by a space.\n"
21920 " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21921 " %h: Equivalent to %b.\n"
21922 " %H: The hour as a decimal number using a 24-hour clock (range\n"
21923 " 00 to 23).\n"
21924 " %I: The hour as a decimal number using a 12-hour clock (range\n"
21925 " 01 to 12).\n"
21926 " %j: The day of the year as a decimal number (range 001 to\n"
21927 " 366).\n"
21928 " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21929 " 23); single digits are preceded by a blank. (See also %H.)\n"
21930 " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21931 " 12); single digits are preceded by a blank. (See also %I.)\n"
21932 " %m: The month as a decimal number (range 01 to 12).\n"
21933 " %M: The minute as a decimal number (range 00 to 59).\n"
21934 " %n: A newline character.\n"
21935 " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21936 " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21937 " %r: Equivalent to %I:%M:%S %p.\n"
21938 " %R: The time in 24-hour notation (%H:%M). For a version\n"
21939 " including the seconds, see %T below.\n"
21940 " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21941 " +0000 (UTC).\n"
21942 " %S: The second as a decimal number (range 00 to 60). (The\n"
21943 " range is up to 60 to allow for occasional leap seconds.)\n"
21944 " %t: A tab character.\n"
21945 " %T: The time in 24-hour notation (%H:%M:%S).\n"
21946 " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21947 " being 1. See also %w.\n"
21948 " %U: The week number of the current year as a decimal number,\n"
21949 " range 00 to 53, starting with the first Sunday as the first\n"
21950 " day of week 01. See also %V and %W.\n"
21951 " %v: Equivalent to %e-%b-%Y.\n"
21952 " %V: The ISO 8601 week number of the current year as a decimal\n"
21953 " number, range 01 to 53, where week 1 is the first week that\n"
21954 " has at least 4 days in the new year. See also %U and %W.\n"
21955 " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21956 " being 0. See also %u.\n"
21957 " %W: The week number of the current year as a decimal number,\n"
21958 " range 00 to 53, starting with the first Monday as the first\n"
21959 " day of week 01.\n"
21960 " %x: Equivalent to %a %b %d %Y.\n"
21961 " %X: Equivalent to %T.\n"
21962 " %y: The year as a decimal number without a century (range 00\n"
21963 " to 99).\n"
21964 " %Y: The year as a decimal number including a century.\n"
21965 " %z: The UTC time-zone string = \"+0000\".\n"
21966 " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
21967 " %+: The UTC date and time in default format of the Unix date\n"
21968 " command which is equivalent to %a %b %d %T %Z %Y.\n"
21969 " %%: A literal \"%\" character.\n"
21970 " The conversion specifications which are extensions to those normally\n"
21971 " provided by system strftime routines are the following: %(0-9):\n"
21972 " The fractional part of the seconds field (including leading\n"
21973 " decimal point) to the specified accuracy. Thus %S%3 would give\n"
21974 " seconds to millisecond accuracy (00.000).\n"
21975 " %.: The fractional part of the seconds field (including\n"
21976 " leading decimal point) to the maximum available accuracy. Thus\n"
21977 " %S%. would give seconds with fractional part up to 9 decimal\n"
21978 " places if available.\n"
21979 "\n"
21980 ""},
21981 { "plvasp", _wrap_plvasp, METH_O, "\n"
21982 "Specify viewport using aspect ratio only\n"
21983 "\n"
21984 "DESCRIPTION:\n"
21985 "\n"
21986 " Selects the largest viewport with the given aspect ratio within the\n"
21987 " subpage that leaves a standard margin (left-hand margin of eight\n"
21988 " character heights, and a margin around the other three sides of five\n"
21989 " character heights).\n"
21990 "\n"
21991 " Redacted form: plvasp(aspect)\n"
21992 "\n"
21993 " This function is used in example 13.\n"
21994 "\n"
21995 "\n"
21996 "\n"
21997 "SYNOPSIS:\n"
21998 "\n"
21999 "plvasp(aspect)\n"
22000 "\n"
22001 "ARGUMENTS:\n"
22002 "\n"
22003 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22004 " axis of resulting viewport.\n"
22005 "\n"
22006 ""},
22007 { "plvect", _wrap_plvect, METH_VARARGS, "\n"
22008 "Vector plot\n"
22009 "\n"
22010 "DESCRIPTION:\n"
22011 "\n"
22012 " Draws a plot of vector data contained in the matrices (\n"
22013 " u[\n"
22014 " nx][\n"
22015 " ny],\n"
22016 " v[\n"
22017 " nx][\n"
22018 " ny]) . The scaling factor for the vectors is given by scale. A\n"
22019 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
22020 " additional data required by the transformation routine to map indices\n"
22021 " within the matrices to the world coordinates. The style of the vector\n"
22022 " arrow may be set using plsvect.\n"
22023 "\n"
22024 " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
22025 " discussion) the pltr, pltr_data callback arguments are sometimes\n"
22026 " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
22027 " with either one or two dimensions.\n"
22028 "\n"
22029 " This function is used in example 22.\n"
22030 "\n"
22031 "\n"
22032 "\n"
22033 "SYNOPSIS:\n"
22034 "\n"
22035 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
22036 "\n"
22037 "ARGUMENTS:\n"
22038 "\n"
22039 " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
22040 " and y components of the vector data to be plotted.\n"
22041 "\n"
22042 " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
22043 "\n"
22044 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
22045 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
22046 " automatically calculated for the data. If scale < 0 then the\n"
22047 " scaling factor is automatically calculated for the data and then\n"
22048 " multiplied by -\n"
22049 " scale. If scale > 0 then the scaling factor is set to scale.\n"
22050 "\n"
22051 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22052 " defines the transformation between the zero-based indices of the\n"
22053 " matrices u and v and world coordinates.For the C case,\n"
22054 " transformation functions are provided in the PLplot library: pltr0\n"
22055 " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
22056 " mappings respectively defined by vectors and matrices. In\n"
22057 " addition, C callback routines for the transformation can be\n"
22058 " supplied by the user such as the mypltr function in\n"
22059 " examples/c/x09c.c which provides a general linear transformation\n"
22060 " between index coordinates and world coordinates.For languages\n"
22061 " other than C you should consult the PLplot documentation for the\n"
22062 " details concerning how PLTRANSFORM_callback arguments are\n"
22063 " interfaced. However, in general, a particular pattern of\n"
22064 " callback-associated arguments such as a tr vector with 6 elements;\n"
22065 " xg and yg vectors; or xg and yg matrices are respectively\n"
22066 " interfaced to a linear-transformation routine similar to the above\n"
22067 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22068 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22069 " support native language callbacks for handling index to\n"
22070 " world-coordinate transformations. Examples of these various\n"
22071 " approaches are given in examples/<language>x09*,\n"
22072 " examples/<language>x16*, examples/<language>x20*,\n"
22073 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22074 " supported languages.\n"
22075 "\n"
22076 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22077 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
22078 " that is externally supplied.\n"
22079 "\n"
22080 ""},
22081 { "plvpas", _wrap_plvpas, METH_VARARGS, "\n"
22082 "Specify viewport using coordinates and aspect ratio\n"
22083 "\n"
22084 "DESCRIPTION:\n"
22085 "\n"
22086 " Device-independent routine for setting up the viewport. The viewport\n"
22087 " is chosen to be the largest with the given aspect ratio that fits\n"
22088 " within the specified region (in terms of normalized subpage\n"
22089 " coordinates). This routine is functionally equivalent to plvpor when\n"
22090 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
22091 " routine reserves no extra space at the edges for labels.\n"
22092 "\n"
22093 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22094 "\n"
22095 " This function is used in example 9.\n"
22096 "\n"
22097 "\n"
22098 "\n"
22099 "SYNOPSIS:\n"
22100 "\n"
22101 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22102 "\n"
22103 "ARGUMENTS:\n"
22104 "\n"
22105 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22106 " left-hand edge of the viewport.\n"
22107 "\n"
22108 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22109 " right-hand edge of the viewport.\n"
22110 "\n"
22111 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22112 " bottom edge of the viewport.\n"
22113 "\n"
22114 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22115 " edge of the viewport.\n"
22116 "\n"
22117 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22118 " axis.\n"
22119 "\n"
22120 ""},
22121 { "plvpor", _wrap_plvpor, METH_VARARGS, "\n"
22122 "Specify viewport using normalized subpage coordinates\n"
22123 "\n"
22124 "DESCRIPTION:\n"
22125 "\n"
22126 " Device-independent routine for setting up the viewport. This defines\n"
22127 " the viewport in terms of normalized subpage coordinates which run from\n"
22128 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
22129 " current subpage. Use the alternate routine plsvpa in order to create\n"
22130 " a viewport of a definite size.\n"
22131 "\n"
22132 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
22133 "\n"
22134 " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
22135 " 24, 26, 27, and 31.\n"
22136 "\n"
22137 "\n"
22138 "\n"
22139 "SYNOPSIS:\n"
22140 "\n"
22141 "plvpor(xmin, xmax, ymin, ymax)\n"
22142 "\n"
22143 "ARGUMENTS:\n"
22144 "\n"
22145 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22146 " left-hand edge of the viewport.\n"
22147 "\n"
22148 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22149 " right-hand edge of the viewport.\n"
22150 "\n"
22151 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22152 " bottom edge of the viewport.\n"
22153 "\n"
22154 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22155 " edge of the viewport.\n"
22156 "\n"
22157 ""},
22158 { "plvsta", _wrap_plvsta, METH_NOARGS, "\n"
22159 "Select standard viewport\n"
22160 "\n"
22161 "DESCRIPTION:\n"
22162 "\n"
22163 " Selects the largest viewport within the subpage that leaves a standard\n"
22164 " margin (left-hand margin of eight character heights, and a margin\n"
22165 " around the other three sides of five character heights).\n"
22166 "\n"
22167 " Redacted form: plvsta()\n"
22168 "\n"
22169 " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
22170 "\n"
22171 "\n"
22172 "\n"
22173 "SYNOPSIS:\n"
22174 "\n"
22175 "plvsta()\n"
22176 "\n"
22177 ""},
22178 { "plw3d", _wrap_plw3d, METH_VARARGS, "\n"
22179 "Configure the transformations required for projecting a 3D surface on a 2D window\n"
22180 "\n"
22181 "DESCRIPTION:\n"
22182 "\n"
22183 " Configure the transformations required for projecting a 3D surface on\n"
22184 " an existing 2D window. Those transformations (see the PLplot\n"
22185 " documentation) are done to a rectangular cuboid enclosing the 3D\n"
22186 " surface which has its limits expressed in 3D world coordinates and\n"
22187 " also normalized 3D coordinates (used for interpreting the altitude and\n"
22188 " azimuth of the viewing angle). The transformations consist of the\n"
22189 " linear transform from 3D world coordinates to normalized 3D\n"
22190 " coordinates, and the 3D rotation of normalized coordinates required to\n"
22191 " align the pole of the new 3D coordinate system with the viewing\n"
22192 " direction specified by altitude and azimuth so that x and y of the\n"
22193 " surface elements in that transformed coordinate system are the\n"
22194 " projection of the 3D surface with given viewing direction on the 2D\n"
22195 " window.\n"
22196 "\n"
22197 " The enclosing rectangular cuboid for the surface plot is defined by\n"
22198 " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
22199 " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
22200 " sizes of basex by basey by height so that xmin maps to -\n"
22201 " basex/2, xmax maps to basex/2, ymin maps to -\n"
22202 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
22203 " The resulting rectangular cuboid in normalized coordinates is then\n"
22204 " viewed by an observer at altitude alt and azimuth az. This routine\n"
22205 " must be called before plbox3 or any of the 3D surface plotting\n"
22206 " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
22207 " plsurf3dl or plfill3.\n"
22208 "\n"
22209 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
22210 " zmin, zmax, alt, az)\n"
22211 "\n"
22212 " This function is examples 8, 11, 18, and 21.\n"
22213 "\n"
22214 "\n"
22215 "\n"
22216 "SYNOPSIS:\n"
22217 "\n"
22218 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
22219 "\n"
22220 "ARGUMENTS:\n"
22221 "\n"
22222 " basex (PLFLT, input) : The normalized x coordinate size of the\n"
22223 " rectangular cuboid.\n"
22224 "\n"
22225 " basey (PLFLT, input) : The normalized y coordinate size of the\n"
22226 " rectangular cuboid.\n"
22227 "\n"
22228 " height (PLFLT, input) : The normalized z coordinate size of the\n"
22229 " rectangular cuboid.\n"
22230 "\n"
22231 " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
22232 " rectangular cuboid.\n"
22233 "\n"
22234 " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
22235 " rectangular cuboid.\n"
22236 "\n"
22237 " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
22238 " rectangular cuboid.\n"
22239 "\n"
22240 " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
22241 " rectangular cuboid.\n"
22242 "\n"
22243 " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
22244 " rectangular cuboid.\n"
22245 "\n"
22246 " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
22247 " rectangular cuboid.\n"
22248 "\n"
22249 " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
22250 " plane of the rectangular cuboid in normalized coordinates.\n"
22251 "\n"
22252 " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
22253 " rectangular cuboid in normalized coordinates. When az=0, the\n"
22254 " observer is looking face onto the zx plane of the rectangular\n"
22255 " cuboid in normalized coordinates, and as az is increased, the\n"
22256 " observer moves clockwise around that cuboid when viewed from above\n"
22257 " the xy plane.\n"
22258 "\n"
22259 ""},
22260 { "plwidth", _wrap_plwidth, METH_O, "\n"
22261 "Set pen width\n"
22262 "\n"
22263 "DESCRIPTION:\n"
22264 "\n"
22265 " Sets the pen width.\n"
22266 "\n"
22267 " Redacted form: plwidth(width)\n"
22268 "\n"
22269 " This function is used in examples 1 and 2.\n"
22270 "\n"
22271 "\n"
22272 "\n"
22273 "SYNOPSIS:\n"
22274 "\n"
22275 "plwidth(width)\n"
22276 "\n"
22277 "ARGUMENTS:\n"
22278 "\n"
22279 " width (PLFLT, input) : The desired pen width. If width is negative\n"
22280 " or the same as the previous value no action is taken. width = 0.\n"
22281 " should be interpreted as as the minimum valid pen width for the\n"
22282 " device. The interpretation of positive width values is also\n"
22283 " device dependent.\n"
22284 "\n"
22285 ""},
22286 { "plwind", _wrap_plwind, METH_VARARGS, "\n"
22287 "Specify window\n"
22288 "\n"
22289 "DESCRIPTION:\n"
22290 "\n"
22291 " Specify the window, i.e., the world coordinates of the edges of the\n"
22292 " viewport.\n"
22293 "\n"
22294 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
22295 "\n"
22296 " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
22297 " 29, and 31.\n"
22298 "\n"
22299 "\n"
22300 "\n"
22301 "SYNOPSIS:\n"
22302 "\n"
22303 "plwind(xmin, xmax, ymin, ymax)\n"
22304 "\n"
22305 "ARGUMENTS:\n"
22306 "\n"
22307 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
22308 " of the viewport.\n"
22309 "\n"
22310 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
22311 " of the viewport.\n"
22312 "\n"
22313 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
22314 " the viewport.\n"
22315 "\n"
22316 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
22317 " viewport.\n"
22318 "\n"
22319 ""},
22320 { "plxormod", _wrap_plxormod, METH_O, "\n"
22321 "Enter or leave xor mode\n"
22322 "\n"
22323 "DESCRIPTION:\n"
22324 "\n"
22325 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
22326 " those drivers (e.g., the xwin driver) that support it. Enables\n"
22327 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
22328 " is not capable of xor operation it returns a status of false.\n"
22329 "\n"
22330 " Redacted form: plxormod(mode, status)\n"
22331 "\n"
22332 " This function is used in examples 1 and 20.\n"
22333 "\n"
22334 "\n"
22335 "\n"
22336 "SYNOPSIS:\n"
22337 "\n"
22338 "plxormod(mode, status)\n"
22339 "\n"
22340 "ARGUMENTS:\n"
22341 "\n"
22342 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
22343 " is false means leave xor mode.\n"
22344 "\n"
22345 " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
22346 " modestatus of true (false) means driver is capable (incapable) of\n"
22347 " xor mode.\n"
22348 "\n"
22349 ""},
22350 { "plmap", _wrap_plmap, METH_VARARGS, "\n"
22351 "Plot continental outline or shapefile data in world coordinates\n"
22352 "\n"
22353 "DESCRIPTION:\n"
22354 "\n"
22355 " Plots continental outlines or shapefile data in world coordinates. A\n"
22356 " demonstration of how to use this function to create different\n"
22357 " projections can be found in examples/c/x19c. PLplot is provided with\n"
22358 " basic coastal outlines and USA state borders. To use the map\n"
22359 " functionality PLplot must be compiled with the shapelib library.\n"
22360 " Shapefiles have become a popular standard for geographical data and\n"
22361 " data in this format can be easily found from a number of online\n"
22362 " sources. Shapefile data is actually provided as three or more files\n"
22363 " with the same filename, but different extensions. The .shp and .shx\n"
22364 " files are required for plotting Shapefile data with PLplot.\n"
22365 "\n"
22366 " PLplot currently supports the point, multipoint, polyline and polygon\n"
22367 " objects within shapefiles. However holes in polygons are not\n"
22368 " supported. When plmap is used the type of object is derived from the\n"
22369 " shapefile, if you wish to override the type then use one of the other\n"
22370 " plmap variants. The built in maps have line data only.\n"
22371 "\n"
22372 " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
22373 "\n"
22374 " This function is used in example 19.\n"
22375 "\n"
22376 "\n"
22377 "\n"
22378 "SYNOPSIS:\n"
22379 "\n"
22380 "plmap(mapform, name, minx, maxx, miny, maxy)\n"
22381 "\n"
22382 "ARGUMENTS:\n"
22383 "\n"
22384 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22385 " transform the original map data coordinates to a new coordinate\n"
22386 " system. The PLplot-supplied map data is provided as latitudes and\n"
22387 " longitudes; other Shapefile data may be provided in other\n"
22388 " coordinate systems as can be found in their .prj plain text files.\n"
22389 " For example, by using this transform we can change from a\n"
22390 " longitude, latitude coordinate to a polar stereographic\n"
22391 " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
22392 " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
22393 " corresponding y coordinates (latitudes for the PLplot supplied\n"
22394 " data). After the call to mapform(), x[] and y[] should be\n"
22395 " replaced by the corresponding plot coordinates. If no transform is\n"
22396 " desired, mapform can be replaced by NULL.\n"
22397 "\n"
22398 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22399 " the type of map plotted. This is either one of the PLplot built-in\n"
22400 " maps or the file name of a set of Shapefile files without the file\n"
22401 " extensions. For the PLplot built-in maps the possible values are:\n"
22402 " \"globe\" -- continental outlines\n"
22403 " \"usa\" -- USA and state boundaries\n"
22404 " \"cglobe\" -- continental outlines and countries\n"
22405 " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
22406 "\n"
22407 "\n"
22408 " minx (PLFLT, input) : The minimum x value of map elements to be\n"
22409 " drawn. The units must match the shapefile (built in maps are\n"
22410 " degrees lat/lon). Objects in the file which do not encroach on the\n"
22411 " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
22412 " note this is simply an optimisation, not a clipping so for objects\n"
22413 " with some points inside the box and some points outside the box\n"
22414 " all the points will be rendered. These parameters also define\n"
22415 " latitude and longitude wrapping for shapefiles using these units.\n"
22416 " Longitude points will be wrapped by integer multiples of 360\n"
22417 " degrees to place them in the box. This allows the same data to be\n"
22418 " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
22419 " you plot from -180-540 you will get two cycles of data drawn. The\n"
22420 " value of minx must be less than the value of maxx. Passing in a\n"
22421 " nan, max/-max floating point number or +/-infinity will case the\n"
22422 " bounding box from the shapefile to be used.\n"
22423 "\n"
22424 " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22425 " drawn - see minx.\n"
22426 "\n"
22427 " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22428 " drawn - see minx.\n"
22429 "\n"
22430 " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22431 " drawn - see minx.\n"
22432 "\n"
22433 ""},
22434 { "plmapline", _wrap_plmapline, METH_VARARGS, "\n"
22435 "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22436 "\n"
22437 "DESCRIPTION:\n"
22438 "\n"
22439 " Plot all or a subset of Shapefile data using lines in world\n"
22440 " coordinates. Our 19th standard example demonstrates how to use this\n"
22441 " function. This function plots data from a Shapefile using lines as in\n"
22442 " plmap, however it also has the option of also only drawing specified\n"
22443 " elements from the Shapefile. The vector of indices of the required\n"
22444 " elements are passed as a function argument. The Shapefile data should\n"
22445 " include a metadata file (extension.dbf) listing all items within the\n"
22446 " Shapefile. This file can be opened by most popular spreadsheet\n"
22447 " programs and can be used to decide which indices to pass to this\n"
22448 " function.\n"
22449 "\n"
22450 " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22451 " plotentries)\n"
22452 "\n"
22453 " This function is used in example 19.\n"
22454 "\n"
22455 "\n"
22456 "\n"
22457 "SYNOPSIS:\n"
22458 "\n"
22459 "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22460 "\n"
22461 "ARGUMENTS:\n"
22462 "\n"
22463 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22464 " transform the coordinates given in the shapefile into a plot\n"
22465 " coordinate system. By using this transform, we can change from a\n"
22466 " longitude, latitude coordinate to a polar stereographic project,\n"
22467 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22468 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22469 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22470 " plot coordinates. If no transform is desired, mapform can be\n"
22471 " replaced by NULL.\n"
22472 "\n"
22473 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22474 " the file name of a set of Shapefile files without the file\n"
22475 " extension.\n"
22476 "\n"
22477 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22478 " be in the same units as used by the Shapefile. You could use a\n"
22479 " very large negative number to plot everything, but you can improve\n"
22480 " performance by limiting the area drawn. The units must match those\n"
22481 " of the Shapefile projection, which may be for example longitude or\n"
22482 " distance. The value of minx must be less than the value of maxx.\n"
22483 "\n"
22484 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22485 " use a very large number to plot everything, but you can improve\n"
22486 " performance by limiting the area drawn.\n"
22487 "\n"
22488 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22489 " be in the same units as used by the Shapefile. You could use a\n"
22490 " very large negative number to plot everything, but you can improve\n"
22491 " performance by limiting the area drawn. The units must match those\n"
22492 " of the Shapefile projection, which may be for example latitude or\n"
22493 " distance. The value of miny must be less than the value of maxy.\n"
22494 "\n"
22495 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22496 " use a very large number to plot everything, but you can improve\n"
22497 " performance by limiting the area drawn.\n"
22498 "\n"
22499 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22500 " zero-based indices of the Shapefile elements which will be drawn.\n"
22501 " Setting\n"
22502 " plotentries to NULL will plot all elements of the Shapefile.\n"
22503 "\n"
22504 " nplotentries (PLINT, input) : The number of items in\n"
22505 " plotentries. Ignored if\n"
22506 " plotentries is NULL.\n"
22507 "\n"
22508 ""},
22509 { "plmapstring", _wrap_plmapstring, METH_VARARGS, "\n"
22510 "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22511 "\n"
22512 "DESCRIPTION:\n"
22513 "\n"
22514 " As per plmapline, however the items are plotted as strings or points\n"
22515 " in the same way as plstring.\n"
22516 "\n"
22517 " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22518 " maxy, plotentries)\n"
22519 "\n"
22520 " This function is not used in any examples.\n"
22521 "\n"
22522 "\n"
22523 "\n"
22524 "SYNOPSIS:\n"
22525 "\n"
22526 "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22527 "\n"
22528 "ARGUMENTS:\n"
22529 "\n"
22530 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22531 " transform the coordinates given in the shapefile into a plot\n"
22532 " coordinate system. By using this transform, we can change from a\n"
22533 " longitude, latitude coordinate to a polar stereographic project,\n"
22534 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22535 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22536 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22537 " plot coordinates. If no transform is desired, mapform can be\n"
22538 " replaced by NULL.\n"
22539 "\n"
22540 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22541 " the file name of a set of Shapefile files without the file\n"
22542 " extension.\n"
22543 "\n"
22544 " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22545 " drawn.\n"
22546 "\n"
22547 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22548 " be in the same units as used by the Shapefile. You could use a\n"
22549 " very large negative number to plot everything, but you can improve\n"
22550 " performance by limiting the area drawn. The units must match those\n"
22551 " of the Shapefile projection, which may be for example longitude or\n"
22552 " distance. The value of minx must be less than the value of maxx.\n"
22553 "\n"
22554 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22555 " use a very large number to plot everything, but you can improve\n"
22556 " performance by limiting the area drawn.\n"
22557 "\n"
22558 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22559 " be in the same units as used by the Shapefile. You could use a\n"
22560 " very large negative number to plot everything, but you can improve\n"
22561 " performance by limiting the area drawn. The units must match those\n"
22562 " of the Shapefile projection, which may be for example latitude or\n"
22563 " distance. The value of miny must be less than the value of maxy.\n"
22564 "\n"
22565 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22566 " use a very large number to plot everything, but you can improve\n"
22567 " performance by limiting the area drawn.\n"
22568 "\n"
22569 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22570 " zero-based indices of the Shapefile elements which will be drawn.\n"
22571 " Setting\n"
22572 " plotentries to NULL will plot all elements of the Shapefile.\n"
22573 "\n"
22574 " nplotentries (PLINT, input) : The number of items in\n"
22575 " plotentries. Ignored if\n"
22576 " plotentries is NULL.\n"
22577 "\n"
22578 ""},
22579 { "plmaptex", _wrap_plmaptex, METH_VARARGS, "\n"
22580 "Draw text at points defined by Shapefile data in world coordinates\n"
22581 "\n"
22582 "DESCRIPTION:\n"
22583 "\n"
22584 " As per plmapline, however the items are plotted as text in the same\n"
22585 " way as plptex.\n"
22586 "\n"
22587 " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22588 " miny, maxy, plotentry)\n"
22589 "\n"
22590 " This function is used in example 19.\n"
22591 "\n"
22592 "\n"
22593 "\n"
22594 "SYNOPSIS:\n"
22595 "\n"
22596 "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22597 "\n"
22598 "ARGUMENTS:\n"
22599 "\n"
22600 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22601 " transform the coordinates given in the shapefile into a plot\n"
22602 " coordinate system. By using this transform, we can change from a\n"
22603 " longitude, latitude coordinate to a polar stereographic project,\n"
22604 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22605 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22606 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22607 " plot coordinates. If no transform is desired, mapform can be\n"
22608 " replaced by NULL.\n"
22609 "\n"
22610 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22611 " the file name of a set of Shapefile files without the file\n"
22612 " extension.\n"
22613 "\n"
22614 " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22615 " dy/dx.\n"
22616 "\n"
22617 " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22618 " dy/dx.\n"
22619 "\n"
22620 " just (PLFLT, input) : Set the justification of the text. The value\n"
22621 " given will be the fraction of the distance along the string that\n"
22622 " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22623 " centralized text and 1.0 gives right aligned text.\n"
22624 "\n"
22625 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22626 "\n"
22627 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22628 " be in the same units as used by the Shapefile. You could use a\n"
22629 " very large negative number to plot everything, but you can improve\n"
22630 " performance by limiting the area drawn. The units must match those\n"
22631 " of the Shapefile projection, which may be for example longitude or\n"
22632 " distance. The value of minx must be less than the value of maxx.\n"
22633 "\n"
22634 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22635 " use a very large number to plot everything, but you can improve\n"
22636 " performance by limiting the area drawn.\n"
22637 "\n"
22638 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22639 " be in the same units as used by the Shapefile. You could use a\n"
22640 " very large negative number to plot everything, but you can improve\n"
22641 " performance by limiting the area drawn. The units must match those\n"
22642 " of the Shapefile projection, which may be for example latitude or\n"
22643 " distance. The value of miny must be less than the value of maxy.\n"
22644 "\n"
22645 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22646 " use a very large number to plot everything, but you can improve\n"
22647 " performance by limiting the area drawn.\n"
22648 "\n"
22649 " plotentry (PLINT, input) : An integer indicating which text string\n"
22650 " of the Shapefile (zero indexed) will be drawn.\n"
22651 "\n"
22652 ""},
22653 { "plmapfill", _wrap_plmapfill, METH_VARARGS, "\n"
22654 "Plot all or a subset of Shapefile data, filling the polygons\n"
22655 "\n"
22656 "DESCRIPTION:\n"
22657 "\n"
22658 " As per plmapline, however the items are filled in the same way as\n"
22659 " plfill.\n"
22660 "\n"
22661 " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22662 " plotentries)\n"
22663 "\n"
22664 " This function is used in example 19.\n"
22665 "\n"
22666 "\n"
22667 "\n"
22668 "SYNOPSIS:\n"
22669 "\n"
22670 "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22671 "\n"
22672 "ARGUMENTS:\n"
22673 "\n"
22674 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22675 " transform the coordinates given in the shapefile into a plot\n"
22676 " coordinate system. By using this transform, we can change from a\n"
22677 " longitude, latitude coordinate to a polar stereographic project,\n"
22678 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22679 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22680 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22681 " plot coordinates. If no transform is desired, mapform can be\n"
22682 " replaced by NULL.\n"
22683 "\n"
22684 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22685 " the file name of a set of Shapefile files without the file\n"
22686 " extension.\n"
22687 "\n"
22688 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22689 " be in the same units as used by the Shapefile. You could use a\n"
22690 " very large negative number to plot everything, but you can improve\n"
22691 " performance by limiting the area drawn. The units must match those\n"
22692 " of the Shapefile projection, which may be for example longitude or\n"
22693 " distance. The value of minx must be less than the value of maxx.\n"
22694 "\n"
22695 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22696 " use a very large number to plot everything, but you can improve\n"
22697 " performance by limiting the area drawn.\n"
22698 "\n"
22699 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22700 " be in the same units as used by the Shapefile. You could use a\n"
22701 " very large negative number to plot everything, but you can improve\n"
22702 " performance by limiting the area drawn. The units must match those\n"
22703 " of the Shapefile projection, which may be for example latitude or\n"
22704 " distance. The value of miny must be less than the value of maxy.\n"
22705 "\n"
22706 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22707 " use a very large number to plot everything, but you can improve\n"
22708 " performance by limiting the area drawn.\n"
22709 "\n"
22710 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22711 " zero-based indices of the Shapefile elements which will be drawn.\n"
22712 " Setting\n"
22713 " plotentries to NULL will plot all elements of the Shapefile.\n"
22714 "\n"
22715 " nplotentries (PLINT, input) : The number of items in\n"
22716 " plotentries. Ignored if\n"
22717 " plotentries is NULL.\n"
22718 "\n"
22719 ""},
22720 { "plmeridians", _wrap_plmeridians, METH_VARARGS, "\n"
22721 "Plot latitude and longitude lines\n"
22722 "\n"
22723 "DESCRIPTION:\n"
22724 "\n"
22725 " Displays latitude and longitude on the current plot. The lines are\n"
22726 " plotted in the current color and line style.\n"
22727 "\n"
22728 " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22729 " minlat, maxlat)\n"
22730 "\n"
22731 " This function is used in example 19.\n"
22732 "\n"
22733 "\n"
22734 "\n"
22735 "SYNOPSIS:\n"
22736 "\n"
22737 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22738 "\n"
22739 "ARGUMENTS:\n"
22740 "\n"
22741 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22742 " transform the coordinate longitudes and latitudes to a plot\n"
22743 " coordinate system. By using this transform, we can change from a\n"
22744 " longitude, latitude coordinate to a polar stereographic project,\n"
22745 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22746 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22747 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22748 " plot coordinates. If no transform is desired, mapform can be\n"
22749 " replaced by NULL.\n"
22750 "\n"
22751 " dlong (PLFLT, input) : The interval in degrees at which the\n"
22752 " longitude lines are to be plotted.\n"
22753 "\n"
22754 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22755 " lines are to be plotted.\n"
22756 "\n"
22757 " minlong (PLFLT, input) : The value of the longitude on the left\n"
22758 " side of the plot. The value of minlong must be less than the value\n"
22759 " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22760 " equal to 360.\n"
22761 "\n"
22762 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22763 " side of the plot.\n"
22764 "\n"
22765 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22766 " background. One can always use -90.0 as the boundary outside the\n"
22767 " plot window will be automatically eliminated. However, the\n"
22768 " program will be faster if one can reduce the size of the\n"
22769 " background plotted.\n"
22770 "\n"
22771 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22772 " background. One can always use 90.0 as the boundary outside the\n"
22773 " plot window will be automatically eliminated.\n"
22774 "\n"
22775 ""},
22776 { "plimage", _wrap_plimage, METH_VARARGS, "\n"
22777 "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22778 "\n"
22779 "DESCRIPTION:\n"
22780 "\n"
22781 " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22782 " automatically adjusted to use the maximum and minimum values in idata\n"
22783 " as valuemin and valuemax in a call to plimagefr.\n"
22784 "\n"
22785 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22786 " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22787 "\n"
22788 "\n"
22789 " This function is used in example 20.\n"
22790 "\n"
22791 "\n"
22792 "\n"
22793 "SYNOPSIS:\n"
22794 "\n"
22795 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22796 "\n"
22797 "ARGUMENTS:\n"
22798 "\n"
22799 " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22800 " to plot. Should have dimensions of\n"
22801 " nx by\n"
22802 " ny.\n"
22803 "\n"
22804 " nx, ny (PLINT, input) : Dimensions of idata\n"
22805 "\n"
22806 " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22807 " are linearly transformed to these world coordinate ranges such\n"
22808 " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22809 " - 1] corresponds to (xmax, ymax).\n"
22810 "\n"
22811 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22812 " (inclusive) will be plotted.\n"
22813 "\n"
22814 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22815 " points whose plot coordinates fall inside the window of (Dxmin,\n"
22816 " Dymin) to (Dxmax, Dymax).\n"
22817 "\n"
22818 ""},
22819 { "plimagefr", _wrap_plimagefr, METH_VARARGS, "\n"
22820 "Plot a 2D matrix using cmap1\n"
22821 "\n"
22822 "DESCRIPTION:\n"
22823 "\n"
22824 " Plot a 2D matrix using cmap1.\n"
22825 "\n"
22826 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22827 " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22828 "\n"
22829 "\n"
22830 " This function is used in example 20.\n"
22831 "\n"
22832 "\n"
22833 "\n"
22834 "SYNOPSIS:\n"
22835 "\n"
22836 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22837 "\n"
22838 "ARGUMENTS:\n"
22839 "\n"
22840 " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22841 " plot. Should have dimensions of\n"
22842 " nx by\n"
22843 " ny.\n"
22844 "\n"
22845 " nx, ny (PLINT, input) : Dimensions of idata\n"
22846 "\n"
22847 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22848 " pltr below for how these arguments are used (only for the special case\n"
22849 " when the callback function\n"
22850 " pltr is not supplied).\n"
22851 "\n"
22852 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22853 " (inclusive) will be plotted.\n"
22854 "\n"
22855 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22856 " values to use for value to color mappings. A datum equal to or\n"
22857 " less than valuemin will be plotted with color 0.0, while a datum\n"
22858 " equal to or greater than valuemax will be plotted with color 1.0.\n"
22859 " Data between valuemin and valuemax map linearly to colors in the\n"
22860 " range (0.0-1.0).\n"
22861 "\n"
22862 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22863 " defines the transformation between the zero-based indices of the\n"
22864 " matrix idata and world coordinates. If\n"
22865 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22866 " indices of idata are mapped to the range\n"
22867 " xmin through\n"
22868 " xmax and the y indices of idata are mapped to the range\n"
22869 " ymin through\n"
22870 " ymax.For the C case, transformation functions are provided in the\n"
22871 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22872 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22873 " matrices. In addition, C callback routines for the transformation\n"
22874 " can be supplied by the user such as the mypltr function in\n"
22875 " examples/c/x09c.c which provides a general linear transformation\n"
22876 " between index coordinates and world coordinates.For languages\n"
22877 " other than C you should consult the PLplot documentation for the\n"
22878 " details concerning how PLTRANSFORM_callback arguments are\n"
22879 " interfaced. However, in general, a particular pattern of\n"
22880 " callback-associated arguments such as a tr vector with 6 elements;\n"
22881 " xg and yg vectors; or xg and yg matrices are respectively\n"
22882 " interfaced to a linear-transformation routine similar to the above\n"
22883 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22884 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22885 " support native language callbacks for handling index to\n"
22886 " world-coordinate transformations. Examples of these various\n"
22887 " approaches are given in examples/<language>x09*,\n"
22888 " examples/<language>x16*, examples/<language>x20*,\n"
22889 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22890 " supported languages.\n"
22891 "\n"
22892 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22893 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22894 " externally supplied.\n"
22895 "\n"
22896 ""},
22897 { "plClearOpts", _wrap_plClearOpts, METH_NOARGS, NULL},
22898 { "plResetOpts", _wrap_plResetOpts, METH_NOARGS, NULL},
22899 { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22900 { "plOptUsage", _wrap_plOptUsage, METH_NOARGS, NULL},
22901 { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_O, NULL},
22902 { "plGetCursor", _wrap_plGetCursor, METH_O, "\n"
22903 "Wait for graphics input event and translate to world coordinates.\n"
22904 "\n"
22905 "DESCRIPTION:\n"
22906 "\n"
22907 " Wait for graphics input event and translate to world coordinates.\n"
22908 " Returns 0 if no translation to world coordinates is possible.\n"
22909 "\n"
22910 " This function returns 1 on success and 0 if no translation to world\n"
22911 " coordinates is possible.\n"
22912 "\n"
22913 " Redacted form: plGetCursor(gin)\n"
22914 "\n"
22915 " This function is used in examples 1 and 20.\n"
22916 "\n"
22917 "\n"
22918 "\n"
22919 "SYNOPSIS:\n"
22920 "\n"
22921 "PLINT plGetCursor(gin)\n"
22922 "\n"
22923 "ARGUMENTS:\n"
22924 "\n"
22925 " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22926 " which will contain the output. The structure is not allocated by\n"
22927 " the routine and must exist before the function is called.\n"
22928 "\n"
22929 ""},
22930 { NULL, NULL, 0, NULL }
22931};
22932
22933
22934/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22935
22936static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22937static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22938static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22939static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22940static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
22941static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
22942static 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};
22943static 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};
22944static 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};
22945static 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};
22946static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
22947static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22948static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22949static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
22950
22967
22968static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
22969static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
22970static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
22971static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
22972static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
22978static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
22979static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
22980static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
22981static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
22982
22999
23000
23001/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23002
23004{0, 0, 0, 0.0, 0, 0}};
23005
23006#ifdef __cplusplus
23007}
23008#endif
23009/* -----------------------------------------------------------------------------
23010 * Type initialization:
23011 * This problem is tough by the requirement that no dynamic
23012 * memory is used. Also, since swig_type_info structures store pointers to
23013 * swig_cast_info structures and swig_cast_info structures store pointers back
23014 * to swig_type_info structures, we need some lookup code at initialization.
23015 * The idea is that swig generates all the structures that are needed.
23016 * The runtime then collects these partially filled structures.
23017 * The SWIG_InitializeModule function takes these initial arrays out of
23018 * swig_module, and does all the lookup, filling in the swig_module.types
23019 * array with the correct data and linking the correct swig_cast_info
23020 * structures together.
23021 *
23022 * The generated swig_type_info structures are assigned statically to an initial
23023 * array. We just loop through that array, and handle each type individually.
23024 * First we lookup if this type has been already loaded, and if so, use the
23025 * loaded structure instead of the generated one. Then we have to fill in the
23026 * cast linked list. The cast data is initially stored in something like a
23027 * two-dimensional array. Each row corresponds to a type (there are the same
23028 * number of rows as there are in the swig_type_initial array). Each entry in
23029 * a column is one of the swig_cast_info structures for that type.
23030 * The cast_initial array is actually an array of arrays, because each row has
23031 * a variable number of columns. So to actually build the cast linked list,
23032 * we find the array of casts associated with the type, and loop through it
23033 * adding the casts to the list. The one last trick we need to do is making
23034 * sure the type pointer in the swig_cast_info struct is correct.
23035 *
23036 * First off, we lookup the cast->type name to see if it is already loaded.
23037 * There are three cases to handle:
23038 * 1) If the cast->type has already been loaded AND the type we are adding
23039 * casting info to has not been loaded (it is in this module), THEN we
23040 * replace the cast->type pointer with the type pointer that has already
23041 * been loaded.
23042 * 2) If BOTH types (the one we are adding casting info to, and the
23043 * cast->type) are loaded, THEN the cast info has already been loaded by
23044 * the previous module so we just ignore it.
23045 * 3) Finally, if cast->type has not already been loaded, then we add that
23046 * swig_cast_info to the linked list (because the cast->type) pointer will
23047 * be correct.
23048 * ----------------------------------------------------------------------------- */
23049
23050#ifdef __cplusplus
23051extern "C" {
23052#if 0
23053} /* c-mode */
23054#endif
23055#endif
23056
23057#if 0
23058#define SWIGRUNTIME_DEBUG
23059#endif
23060
23061#ifndef SWIG_INIT_CLIENT_DATA_TYPE
23062#define SWIG_INIT_CLIENT_DATA_TYPE void *
23063#endif
23064
23065SWIGRUNTIME void
23067 size_t i;
23068 swig_module_info *module_head, *iter;
23069 int init;
23070
23071 /* check to see if the circular list has been setup, if not, set it up */
23072 if (swig_module.next==0) {
23073 /* Initialize the swig_module */
23077 init = 1;
23078 } else {
23079 init = 0;
23080 }
23081
23082 /* Try and load any already created modules */
23083 module_head = SWIG_GetModule(clientdata);
23084 if (!module_head) {
23085 /* This is the first module loaded for this interpreter */
23086 /* so set the swig module into the interpreter */
23087 SWIG_SetModule(clientdata, &swig_module);
23088 } else {
23089 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
23090 iter=module_head;
23091 do {
23092 if (iter==&swig_module) {
23093 /* Our module is already in the list, so there's nothing more to do. */
23094 return;
23095 }
23096 iter=iter->next;
23097 } while (iter!= module_head);
23098
23099 /* otherwise we must add our module into the list */
23100 swig_module.next = module_head->next;
23101 module_head->next = &swig_module;
23102 }
23103
23104 /* When multiple interpreters are used, a module could have already been initialized in
23105 a different interpreter, but not yet have a pointer in this interpreter.
23106 In this case, we do not want to continue adding types... everything should be
23107 set up already */
23108 if (init == 0) return;
23109
23110 /* Now work on filling in swig_module.types */
23111#ifdef SWIGRUNTIME_DEBUG
23112 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
23113#endif
23114 for (i = 0; i < swig_module.size; ++i) {
23115 swig_type_info *type = 0;
23116 swig_type_info *ret;
23117 swig_cast_info *cast;
23118
23119#ifdef SWIGRUNTIME_DEBUG
23120 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23121#endif
23122
23123 /* if there is another module already loaded */
23124 if (swig_module.next != &swig_module) {
23126 }
23127 if (type) {
23128 /* Overwrite clientdata field */
23129#ifdef SWIGRUNTIME_DEBUG
23130 printf("SWIG_InitializeModule: found type %s\n", type->name);
23131#endif
23133 type->clientdata = swig_module.type_initial[i]->clientdata;
23134#ifdef SWIGRUNTIME_DEBUG
23135 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23136#endif
23137 }
23138 } else {
23139 type = swig_module.type_initial[i];
23140 }
23141
23142 /* Insert casting types */
23143 cast = swig_module.cast_initial[i];
23144 while (cast->type) {
23145 /* Don't need to add information already in the list */
23146 ret = 0;
23147#ifdef SWIGRUNTIME_DEBUG
23148 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23149#endif
23150 if (swig_module.next != &swig_module) {
23152#ifdef SWIGRUNTIME_DEBUG
23153 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23154#endif
23155 }
23156 if (ret) {
23157 if (type == swig_module.type_initial[i]) {
23158#ifdef SWIGRUNTIME_DEBUG
23159 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23160#endif
23161 cast->type = ret;
23162 ret = 0;
23163 } else {
23164 /* Check for casting already in the list */
23165 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23166#ifdef SWIGRUNTIME_DEBUG
23167 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23168#endif
23169 if (!ocast) ret = 0;
23170 }
23171 }
23172
23173 if (!ret) {
23174#ifdef SWIGRUNTIME_DEBUG
23175 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23176#endif
23177 if (type->cast) {
23178 type->cast->prev = cast;
23179 cast->next = type->cast;
23180 }
23181 type->cast = cast;
23182 }
23183 cast++;
23184 }
23185 /* Set entry in modules->types array equal to the type */
23186 swig_module.types[i] = type;
23187 }
23188 swig_module.types[i] = 0;
23189
23190#ifdef SWIGRUNTIME_DEBUG
23191 printf("**** SWIG_InitializeModule: Cast List ******\n");
23192 for (i = 0; i < swig_module.size; ++i) {
23193 int j = 0;
23195 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23196 while (cast->type) {
23197 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23198 cast++;
23199 ++j;
23200 }
23201 printf("---- Total casts: %d\n",j);
23202 }
23203 printf("**** SWIG_InitializeModule: Cast List ******\n");
23204#endif
23205}
23206
23207/* This function will propagate the clientdata field of type to
23208* any new swig_type_info structures that have been added into the list
23209* of equivalent types. It is like calling
23210* SWIG_TypeClientData(type, clientdata) a second time.
23211*/
23212SWIGRUNTIME void
23214 size_t i;
23215 swig_cast_info *equiv;
23216 static int init_run = 0;
23217
23218 if (init_run) return;
23219 init_run = 1;
23220
23221 for (i = 0; i < swig_module.size; i++) {
23222 if (swig_module.types[i]->clientdata) {
23223 equiv = swig_module.types[i]->cast;
23224 while (equiv) {
23225 if (!equiv->converter) {
23226 if (equiv->type && !equiv->type->clientdata)
23228 }
23229 equiv = equiv->next;
23230 }
23231 }
23232 }
23233}
23234
23235#ifdef __cplusplus
23236#if 0
23237{
23238 /* c-mode */
23239#endif
23240}
23241#endif
23242
23243
23244
23245#ifdef __cplusplus
23246extern "C" {
23247#endif
23248
23249 /* -----------------------------------------------------------------------------
23250 * constants/methods manipulation
23251 * ----------------------------------------------------------------------------- */
23252
23253 /* Install Constants */
23254 SWIGINTERN void
23256 PyObject *obj = 0;
23257 size_t i;
23258 for (i = 0; constants[i].type; ++i) {
23259 switch(constants[i].type) {
23260 case SWIG_PY_POINTER:
23261 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23262 break;
23263 case SWIG_PY_BINARY:
23264 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23265 break;
23266 default:
23267 obj = 0;
23268 break;
23269 }
23270 if (obj) {
23271 PyDict_SetItemString(d, constants[i].name, obj);
23272 Py_DECREF(obj);
23273 }
23274 }
23275 }
23276
23277 /* -----------------------------------------------------------------------------
23278 * Patch %callback methods' docstrings to hold the callback ptrs
23279 * -----------------------------------------------------------------------------*/
23280
23281 SWIGINTERN void
23282 SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
23283 size_t i;
23284 for (i = 0; methods[i].ml_name; ++i) {
23285 const char *c = methods[i].ml_doc;
23286 if (!c) continue;
23287 c = strstr(c, "swig_ptr: ");
23288 if (c) {
23289 int j;
23290 const swig_const_info *ci = 0;
23291 const char *name = c + 10;
23292 for (j = 0; const_table[j].type; ++j) {
23293 if (strncmp(const_table[j].name, name,
23294 strlen(const_table[j].name)) == 0) {
23295 ci = &(const_table[j]);
23296 break;
23297 }
23298 }
23299 if (ci) {
23300 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23301 if (ptr) {
23302 size_t shift = (ci->ptype) - types;
23303 swig_type_info *ty = types_initial[shift];
23304 size_t ldoc = (c - methods[i].ml_doc);
23305 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23306 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23307 if (ndoc) {
23308 char *buff = ndoc;
23309 memcpy(buff, methods[i].ml_doc, ldoc);
23310 buff += ldoc;
23311 memcpy(buff, "swig_ptr: ", 10);
23312 buff += 10;
23313 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23314 methods[i].ml_doc = ndoc;
23315 }
23316 }
23317 }
23318 }
23319 }
23320 }
23321
23322#ifdef __cplusplus
23323}
23324#endif
23325
23326
23327
23328
23329/* -----------------------------------------------------------------------------*
23330 * Partial Init method
23331 * -----------------------------------------------------------------------------*/
23332
23333#ifdef __cplusplus
23334extern "C"
23335#endif
23336
23338#if PY_VERSION_HEX >= 0x03000000
23339PyObject*
23340#else
23341void
23342#endif
23344 PyObject *m, *d, *md, *globals;
23345
23346#if PY_VERSION_HEX >= 0x03000000
23347 static struct PyModuleDef SWIG_module = {
23348 PyModuleDef_HEAD_INIT,
23349 SWIG_name,
23350 NULL,
23351 -1,
23353 NULL,
23354 NULL,
23355 NULL,
23356 NULL
23357 };
23358#endif
23359
23360#if defined(SWIGPYTHON_BUILTIN)
23361 static SwigPyClientData SwigPyObject_clientdata = {
23362 0, 0, 0, 0, 0, 0, 0
23363 };
23364 static PyGetSetDef this_getset_def = {
23365 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23366 };
23367 static SwigPyGetSet thisown_getset_closure = {
23370 };
23371 static PyGetSetDef thisown_getset_def = {
23372 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23373 };
23374 PyTypeObject *builtin_pytype;
23375 int builtin_base_count;
23376 swig_type_info *builtin_basetype;
23377 PyObject *tuple;
23378 PyGetSetDescrObject *static_getset;
23379 PyTypeObject *metatype;
23380 PyTypeObject *swigpyobject;
23381 SwigPyClientData *cd;
23382 PyObject *public_interface, *public_symbol;
23383 PyObject *this_descr;
23384 PyObject *thisown_descr;
23385 PyObject *self = 0;
23386 int i;
23387
23388 (void)builtin_pytype;
23389 (void)builtin_base_count;
23390 (void)builtin_basetype;
23391 (void)tuple;
23392 (void)static_getset;
23393 (void)self;
23394
23395 /* Metaclass is used to implement static member variables */
23396 metatype = SwigPyObjectType();
23397 assert(metatype);
23398#endif
23399
23400 (void)globals;
23401
23402 /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
23403 SWIG_This();
23406#ifndef SWIGPYTHON_BUILTIN
23408#endif
23409
23410 /* Fix SwigMethods to carry the callback ptrs when needed */
23412
23413#if PY_VERSION_HEX >= 0x03000000
23414 m = PyModule_Create(&SWIG_module);
23415#else
23416 m = Py_InitModule(SWIG_name, SwigMethods);
23417#endif
23418
23419 md = d = PyModule_GetDict(m);
23420 (void)md;
23421
23423
23424#ifdef SWIGPYTHON_BUILTIN
23425 swigpyobject = SwigPyObject_TypeOnce();
23426
23427 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23428 assert(SwigPyObject_stype);
23429 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23430 if (!cd) {
23431 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23432 SwigPyObject_clientdata.pytype = swigpyobject;
23433 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
23434 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23435# if PY_VERSION_HEX >= 0x03000000
23436 return NULL;
23437# else
23438 return;
23439# endif
23440 }
23441
23442 /* All objects have a 'this' attribute */
23443 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23444 (void)this_descr;
23445
23446 /* All objects have a 'thisown' attribute */
23447 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23448 (void)thisown_descr;
23449
23450 public_interface = PyList_New(0);
23451 public_symbol = 0;
23452 (void)public_symbol;
23453
23454 PyDict_SetItemString(md, "__all__", public_interface);
23455 Py_DECREF(public_interface);
23456 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23457 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23458 for (i = 0; swig_const_table[i].name != 0; ++i)
23459 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23460#endif
23461
23463
23464
23465 import_array();
23466
23467 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23468 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23469 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23470 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23471 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23472 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23473 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23474 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23475 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23476 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23477 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23478 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23479 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23480 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23481 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23482 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23483 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23484 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23485 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23486 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23487 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23488 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23489 SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23490 SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23491 SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23492 SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23493 SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23494 SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23495 SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23496 SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23497 SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23498 SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23499 SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23500 SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23501 SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23502 SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23503 SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23504 SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23505 SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23506 SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23507 SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23508 SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23509 SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23510 SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23511 SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23512 SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23513 SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23514 SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23515 SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23516 SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23517 SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23518 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23519 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23520 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23521 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23522 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23523 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23524 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23525 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23526 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23527 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23528 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23529 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23530 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23531 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23532 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23533 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23534 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23535 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23536 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23537 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23538 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23539 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23540 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23541 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23542 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23543 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23544 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23545 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23546 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23547 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23548 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23549 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23550 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23551 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23552 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23553 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23554 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23555 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23556 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23557 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23558 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23559 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23560 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23561 SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23562 SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23563 SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23564 SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23565 SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23566 SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23567 SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23568 SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23569 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23570 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23571 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23572 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23573 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23574 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23575 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23576 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL0",SWIG_From_int((int)(16)));
23577 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL1",SWIG_From_int((int)(128)));
23578 SWIG_Python_SetConstant(d, "MIN_PLINT_RGB",SWIG_From_int((int)(0)));
23579 SWIG_Python_SetConstant(d, "MAX_PLINT_RGB",SWIG_From_int((int)(255)));
23580 SWIG_Python_SetConstant(d, "MIN_PLFLT_CMAP1",SWIG_From_double((double)(0.)));
23581 SWIG_Python_SetConstant(d, "MAX_PLFLT_CMAP1",SWIG_From_double((double)(1.)));
23582 SWIG_Python_SetConstant(d, "MIN_PLFLT_ALPHA",SWIG_From_double((double)(0.)));
23583 SWIG_Python_SetConstant(d, "MAX_PLFLT_ALPHA",SWIG_From_double((double)(1.)));
23584 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23585 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23586 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23587 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23588 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23589 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23590 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23591 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23592 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23593 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23594 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23595 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23596 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23597 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23598 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23599 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23600 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23601 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23602 SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23603 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23604 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23605 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23606 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23607 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23608 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23609 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23610 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23611 SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23612 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23613 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23614 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23615 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23616 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23617 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23618 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23619 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23620 SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23621 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23622 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23623 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23624 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23625 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23626 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23627 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23628 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23629 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23630 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23631 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23632 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23633 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23634 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23635 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23636 SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23637 SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23638 SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23639 SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23640 SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23641 SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23642 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23643 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23644 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23645 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23646 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23647 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23648 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23649 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23650 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23651 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23652#if PY_VERSION_HEX >= 0x03000000
23653 return m;
23654#else
23655 return;
23656#endif
23657}
23658
#define min(x, y)
Definition nnpi.c:87
#define max(x, y)
Definition nnpi.c:88
void plOptUsage(void)
Definition plargs.c:1304
void plClearOpts(void)
Definition plargs.c:830
void plResetOpts(void)
Definition plargs.c:843
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition plargs.c:1287
static int error
Definition plcont.c:61
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:941
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:874
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition plcont.c:858
void plsxwin(PLINT window_id)
Definition plcore.c:3978
static PLFLT value(double n1, double n2, double hue)
Definition plctrl.c:1219
void plMinMax2dGrid(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLFLT *fnmax, PLFLT *fnmin)
Definition plmem.c:141
PLINT plGetCursor(PLGraphicsIn *plg)
Definition plpage.c:244
#define plgfci
Definition plplot.h:735
#define plgstrm
Definition plplot.h:744
#define plpat
Definition plplot.h:779
#define plschr
Definition plplot.h:790
#define plfontld
Definition plplot.h:721
#define plpath
Definition plplot.h:761
#define plerry
Definition plplot.h:715
#define plsfam
Definition plplot.h:816
#define plsmaj
Definition plplot.h:826
#define plsmin
Definition plplot.h:829
#define pleop
Definition plplot.h:713
#define plimage
Definition plplot.h:753
#define plstransform
Definition plplot.h:840
#define plmap
Definition plplot.h:764
#define plfill
Definition plplot.h:717
#define plvpas
Definition plplot.h:859
#define plgdiplt
Definition plplot.h:732
#define plerrx
Definition plplot.h:714
#define plinit
Definition plplot.h:755
#define plscmap1l
Definition plplot.h:796
#define plsori
Definition plplot.h:830
#define plbox3
Definition plplot.h:698
#define plmapfill
Definition plplot.h:768
#define plcol1
Definition plplot.h:703
#define pltimefmt
Definition plplot.h:856
PLUINT PLUNICODE
Definition plplot.h:201
#define plmaptex
Definition plplot.h:767
#define plvect
Definition plplot.h:858
#define plgchr
Definition plplot.h:722
float PLFLT
Definition plplot.h:163
#define pllegend
Definition plplot.h:758
#define plsyax
Definition plplot.h:852
#define plgver
Definition plplot.h:745
#define plscolbg
Definition plplot.h:802
#define plpsty
Definition plplot.h:784
#define plgfont
Definition plplot.h:737
#define plenv
Definition plplot.h:711
#define pllightsource
Definition plplot.h:759
#define plsmema
Definition plplot.h:828
#define plpoin3
Definition plplot.h:781
#define plgspa
Definition plplot.h:743
#define plscol0
Definition plplot.h:800
#define plptex
Definition plplot.h:785
#define plrgbhls
Definition plplot.h:789
#define plbop
Definition plplot.h:696
#define plgdidev
Definition plplot.h:730
#define plpoin
Definition plplot.h:780
#define plptex3
Definition plplot.h:786
#define plstripd
Definition plplot.h:845
#define plhist
Definition plplot.h:751
#define plmapline
Definition plplot.h:765
#define plgfnam
Definition plplot.h:736
#define plgdiori
Definition plplot.h:731
#define plszax
Definition plplot.h:854
#define plsmem
Definition plplot.h:827
#define plstripa
Definition plplot.h:843
#define plgxax
Definition plplot.h:748
#define plgra
Definition plplot.h:740
#define plenv0
Definition plplot.h:712
#define plspal1
Definition plplot.h:833
#define plstring3
Definition plplot.h:842
#define plxormod
Definition plplot.h:865
#define plspause
Definition plplot.h:834
#define plgdev
Definition plplot.h:729
#define plgradient
Definition plplot.h:741
#define plspal0
Definition plplot.h:832
#define plcalc_world
Definition plplot.h:700
#define plwidth
Definition plplot.h:863
#define pllab
Definition plplot.h:757
#define plsurf3d
Definition plplot.h:847
#define plsurf3dl
Definition plplot.h:848
#define plvasp
Definition plplot.h:857
#define plscmap0n
Definition plplot.h:793
#define plmtex3
Definition plplot.h:774
#define plctime
Definition plplot.h:708
#define plclear
Definition plplot.h:701
#define plsvpa
Definition plplot.h:850
#define plw3d
Definition plplot.h:862
#define plot3dcl
Definition plplot.h:777
#define plscmap1n
Definition plplot.h:798
#define plgvpd
Definition plplot.h:746
#define plhlsrgb
Definition plplot.h:752
#define pl_setcontlabelformat
Definition plplot.h:690
#define plsdev
Definition plplot.h:806
#define plconfigtime
Definition plplot.h:705
#define plscolbga
Definition plplot.h:803
#define PL_UNUSED(x)
Definition plplot.h:138
#define plscmap1
Definition plplot.h:794
#define plsdiplz
Definition plplot.h:811
#define plparseopts
Definition plplot.h:778
#define plmapstring
Definition plplot.h:766
#define plot3d
Definition plplot.h:775
#define plsesc
Definition plplot.h:814
#define plarc
Definition plplot.h:693
#define plsetopt
Definition plplot.h:815
#define plgvpw
Definition plplot.h:747
#define pltext
Definition plplot.h:855
#define plstring
Definition plplot.h:841
#define plsdiori
Definition plplot.h:809
#define plcont
Definition plplot.h:706
#define plspage
Definition plplot.h:831
#define plaxes
Definition plplot.h:694
#define pllsty
Definition plplot.h:763
#define plslabelfunc
Definition plplot.h:825
#define plshades
Definition plplot.h:824
#define plglevel
Definition plplot.h:738
#define plscompression
Definition plplot.h:805
#define plfamadv
Definition plplot.h:716
#define plfont
Definition plplot.h:720
#define plscmap0a
Definition plplot.h:792
#define plgcol0a
Definition plplot.h:725
#define plscmap1_range
Definition plplot.h:799
#define plmeshc
Definition plplot.h:771
#define plshade
Definition plplot.h:820
#define plsym
Definition plplot.h:853
#define plscmap1a
Definition plplot.h:795
#define plscmap0
Definition plplot.h:791
#define plgriddata
Definition plplot.h:742
#define plstripc
Definition plplot.h:844
#define pl_setcontlabelparam
Definition plplot.h:691
#define plsvect
Definition plplot.h:849
#define plstyl
Definition plplot.h:846
#define plline
Definition plplot.h:760
#define pljoin
Definition plplot.h:756
#define plgzax
Definition plplot.h:750
#define plsstrm
Definition plplot.h:835
#define plscmap1la
Definition plplot.h:797
#define plssym
Definition plplot.h:837
#define plscolor
Definition plplot.h:804
#define plcol0
Definition plplot.h:702
#define plsdiplt
Definition plplot.h:810
#define plcolorbar
Definition plplot.h:704
#define plvsta
Definition plplot.h:861
#define plmeridians
Definition plplot.h:769
#define plot3dc
Definition plplot.h:776
#define plcpstrm
Definition plplot.h:707
#define plmkstrm
Definition plplot.h:772
#define plgcol0
Definition plplot.h:724
#define pladv
Definition plplot.h:692
#define plgcolbga
Definition plplot.h:727
#define plline3
Definition plplot.h:762
#define plprec
Definition plplot.h:783
#define plfill3
Definition plplot.h:718
#define plseed
Definition plplot.h:813
#define plgcompression
Definition plplot.h:728
#define plimagefr
Definition plplot.h:754
#define plsfont
Definition plplot.h:819
int PLINT
Definition plplot.h:181
#define plgfam
Definition plplot.h:734
#define plscol0a
Definition plplot.h:801
#define plend1
Definition plplot.h:710
#define plrandd
Definition plplot.h:787
#define plbin
Definition plplot.h:695
#define plsdidev
Definition plplot.h:807
#define plsfnam
Definition plplot.h:818
void * PLPointer
Definition plplot.h:209
#define plflush
Definition plplot.h:719
#define plwind
Definition plplot.h:864
#define plstar
Definition plplot.h:838
#define plmtex
Definition plplot.h:773
PLINT PLBOOL
Definition plplot.h:204
#define plsdimap
Definition plplot.h:808
#define plsfci
Definition plplot.h:817
#define plend
Definition plplot.h:709
#define plmesh
Definition plplot.h:770
#define plreplot
Definition plplot.h:788
#define plgcolbg
Definition plplot.h:726
#define plgcmap1_range
Definition plplot.h:723
#define plstart
Definition plplot.h:839
#define plsxax
Definition plplot.h:851
#define plbox
Definition plplot.h:697
#define plbtime
Definition plplot.h:699
#define plgyax
Definition plplot.h:749
#define plvpor
Definition plplot.h:860
#define plpoly3
Definition plplot.h:782
#define plgpage
Definition plplot.h:739
#define plssub
Definition plplot.h:836
SWIGINTERN PyObject * _wrap_plstransform(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *self, PyObject *args)
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *self, PyObject *args)
static swig_cast_info * swig_cast_initial[]
SWIGINTERN int swig_varlink_setattr(PyObject *o, char *n, PyObject *p)
SWIGINTERN PyObject * _wrap_plgra(PyObject *self, PyObject *args)
static int interpreter_counter
static PLcGrid2 tmpGrid2
SWIGINTERN PyObject * _wrap_plvpas(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *self, PyObject *args)
#define SWIG_MangledTypeQuery(name)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args)
static PLcGrid tmpGrid1
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *self, PyObject *args)
static PyObject * Swig_This_global
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
static swig_cast_info _swigc__p_PLcGrid2[]
SWIGINTERN PyObject * _wrap_plerrx(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *self, PyObject *args)
SWIGINTERN Py_ssize_t SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
#define SWIG_TypeQuery(name)
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *self, PyObject *args)
#define SWIG_POINTER_OWN
SWIGINTERN PyObject * _wrap_plfill3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args)
#define SWIG_SyntaxError
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *self, PyObject *args)
#define SWIG_POINTER_NEW
SWIGINTERN PyObject * _wrap_plgfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *self, PyObject *args)
#define SWIG_CheckState(r)
static swig_cast_info _swigc__p_f_double_double__int[]
void cleanup_mapform(void)
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_int[]
SWIGINTERN PyObject * _wrap_plschr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstart(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args)
#define SWIG_BUFFER_SIZE
#define SWIG_TypeError
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
pltr_func marshal_pltr(PyObject *input)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args)
static PLINT Alen
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args)
#define myArray_ContiguousFromObject
SWIGRUNTIME PyObject * SwigPyObject_next(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plend(PyObject *self, PyObject *args)
#define SWIG_POINTER_IMPLICIT_CONV
static swig_cast_info _swigc__p_double[]
#define SWIGTYPE_p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *self, PyObject *args)
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plbin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *self, PyObject *args)
#define SWIG_PY_POINTER
struct swig_cast_info swig_cast_info
SWIGINTERN PyObject * _wrap_plpoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *self, PyObject *args)
#define SWIG_init
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
#define SWIG_PYTHON_THREAD_END_BLOCK
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *self, PyObject *args)
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *self, PyObject *args)
#define SWIG_RuntimeError
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
SWIGINTERN PyObject * _wrap_pladv(PyObject *self, PyObject *args)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *self, PyObject *args)
#define SWIGPY_CAPSULE_ATTR_NAME
SWIGINTERN PyObject * _wrap_plsfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmema(PyObject *self, PyObject *args)
struct swig_varlinkobject swig_varlinkobject
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *self, PyObject *args)
#define SWIG_NewClientData(obj)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *self, PyObject *args)
mapform_func marshal_mapform(PyObject *input)
#define PyObject_DEL
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGINTERN PyObject * _wrap_plline(PyObject *self, PyObject *args)
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *self, PyObject *args)
#define SWIGRUNTIME
SWIGINTERN PyObject * _wrap_plvasp(PyObject *self, PyObject *args)
#define SWIG_PY_BINARY
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *self, PyObject *args)
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *self, PyObject *args)
PyObject * python_f2eval
#define SWIG_RUNTIME_VERSION
SWIGINTERN PyObject * _wrap_plscolor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
SWIGINTERN PyObject * _wrap_plssym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *self, PyObject *args)
#define SWIG_POINTER_NOSHADOW
SWIGINTERN PyObject * _wrap_plwind(PyObject *self, PyObject *args)
#define SWIG_OLDOBJ
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
#define SWIG_ValueError
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGINTERN PyObject * _wrap_plend1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *self, PyObject *args)
#define t_output_helper
SWIGINTERN PyObject * _wrap_plsmin(PyObject *self, PyObject *args)
static PyMethodDef swigobject_methods[]
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *self, PyObject *args)
#define SWIG_AddCast(r)
void cleanup_PLcGrid1(void)
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
#define SWIG_IsNewObj(r)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *self, PyObject *args)
#define SWIG_InternalNewPointerObj(ptr, type, flags)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *self, PyObject *args)
#define NPY_PLFLT
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
#define SWIG_exception_fail(code, msg)
void cleanup_ct(void)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltr2(PyObject *self, PyObject *args)
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args)
#define SWIG_AttributeError
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args)
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args)
static swig_module_info swig_module
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *self, PyObject *args)
static PLINT Ylen
SWIGINTERN PyObject * _wrap_pltr1(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_double
SWIGINTERN PyObject * _wrap_plgdev(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_TypeErrorOccurred(PyObject *obj)
SWIGRUNTIME void SWIG_Python_DestroyModule(PyObject *obj)
#define SWIG_SetModule(clientdata, pointer)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *self, PyObject *args)
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
SWIGINTERN PyObject * swig_varlink_str(PyObject *o)
SWIGINTERN PyTypeObject * swig_varlink_type(void)
SWIGINTERN PyObject * _wrap_pllab(PyObject *self, PyObject *args)
#define SWIG_INIT_CLIENT_DATA_TYPE
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *self, PyObject *args)
#define SWIGUNUSEDPARM(p)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *self, PyObject *args)
PLPointer marshal_PLPointer(PyObject *input, int isimg)
#define SWIG_POINTER_RELEASE
SWIGINTERN PyObject * _wrap_plstring3(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define SWIG_as_voidptr(a)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
static swig_const_info swig_const_table[]
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plscol0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
static swig_type_info _swigt__p_p_char
#define SWIG_Python_CallFunctor(functor, obj)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
static swig_type_info _swigt__p_p_double
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *self, PyObject *args)
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
#define SWIG_POINTER_CLEAR
PyObject * python_label
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
#define SWIGTYPE_p_int
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
struct swig_const_info swig_const_info
SWIGINTERN PyObject * _wrap_plpsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plimage(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *self, PyObject *args)
static PyObject * Swig_Globals_global
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *self, PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *self, PyObject *args)
#define SWIG_newvarlink()
SWIGRUNTIME void SWIG_Python_RaiseOrModifyTypeError(const char *message)
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
SWIGINTERN const char * SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
PLINT(* defined_func)(PLFLT, PLFLT)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *self, PyObject *args)
void cleanup_pltr(void)
void cleanup_PLcGrid2(void)
static PyObject * Swig_TypeCache_global
SWIGINTERN PyObject * _wrap_plglevel(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_p_double[]
#define SWIGINTERN
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
SWIGINTERN PyObject * _wrap_plpath(PyObject *self, PyObject *args)
#define SWIG_From_double
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
struct swig_globalvar swig_globalvar
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
#define SWIGPY_CAPSULE_NAME
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
#define SWIG_ArgError(r)
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
PyObject * python_pltr
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
#define SWIG_NewPointerObj(ptr, type, flags)
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *self, PyObject *args)
ct_func marshal_ct(PyObject *input)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *self, PyObject *args)
#define SWIG_POINTER_NO_NULL
#define SWIG_Python_str_FromFormat
#define SWIG_InstallConstants(d, constants)
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *self, PyObject *args)
#define SWIG_IOError
static PyMethodDef SwigMethods[]
#define SWIG_NullReferenceError
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_pleop(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
#define SWIG_POINTER_DISOWN
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args)
#define SWIG_STATIC_POINTER(var)
struct swig_type_info swig_type_info
PyObject * python_mapform
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v))
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
static swig_type_info _swigt__p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plflush(PyObject *self, PyObject *args)
#define SWIG_IsTmpObj(r)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_f_double_double__int
SWIGINTERN PyObject * _wrap_plcont(PyObject *self, PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
SWIGINTERN PyObject * _wrap_plsori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plbop(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
#define SWIG_NEWOBJ
#define MY_BLOCK_THREADS
SWIGINTERN PyObject * _wrap_plgver(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *self, PyObject *args)
#define SWIG_TMPOBJ
SWIGINTERN PyObject * _wrap_pllsty(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
#define SWIG_DelNewMask(r)
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *self, PyObject *args)
#define SWIG_NewPackedObj(ptr, sz, type)
static swig_cast_info _swigc__p_PLcGrid[]
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *self, PyObject *args)
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
#define SWIG_GetModule(clientdata)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_unsigned_int[]
#define SWIG_fail
static swig_type_info _swigt__p_int
SWIGINTERN PyObject * PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *self, PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty)
SWIGRUNTIME void SWIG_PropagateClientData(void)
PyArrayObject * pltr_xg
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
#define NPY_PLINT
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
SWIGINTERN PyObject * _wrap_plsmem(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *self, PyObject *args)
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
#define SWIG_ERROR_RELEASE_NOT_OWNED
SWIGRUNTIME PyObject * SWIG_This(void)
SWIGINTERN PyObject * _wrap_plenv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_PLcGrid
#define SWIG_BUILTIN_TP_INIT
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
SWIGINTERN void swig_varlink_dealloc(PyObject *o)
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v)
static PLINT Xlen
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
SWIGINTERN PyObject * _wrap_plfont(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *self, PyObject *args)
PyArrayObject * pltr_yg
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args)
struct swig_module_info swig_module_info
PyObject * python_ct
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
#define SWIG_ERROR
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
#define SWIG_name
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *self, PyObject *args)
static swig_type_info * swig_type_initial[]
SWIGINTERN PyObject * _wrap_plerry(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *self, PyObject *args)
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
#define PySequence_Fast_GET_ITEM
SWIGINTERN PyObject * _wrap_plmap(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
SWIGINTERN PyObject * _wrap_plhist(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGINTERN PyObject * _wrap_pltr0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *self, PyObject *args)
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_getattr(PyObject *o, char *n)
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args)
#define PySequence_Size
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *self, PyObject *args)
#define SWIG_MemoryError
SWIGINTERN PyObject * _wrap_plfontld(PyObject *self, PyObject *args)
#define SWIG_SystemError
#define SWIG_DivisionByZero
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args)
#define SWIGTYPE_p_double
static swig_type_info _swigt__p_char
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
#define SWIG_OverflowError
#define SWIGEXPORT
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
#define SWIG_IsOK(r)
SWIGINTERN PyObject * _wrap_plstring(PyObject *self, PyObject *args)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
static PyObject * Swig_Capsule_global
static swig_type_info _swigt__p_PLcGrid2
SWIGINTERN PyObject * _wrap_plctime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *self, PyObject *args)
#define SWIG_IndexError
SWIGINTERN PyObject * _wrap_plspal0(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
static swig_type_info * swig_types[15]
SWIGRUNTIME PyObject * SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *self, PyObject *args)
#define SWIG_AddNewMask(r)
SWIGINTERN PyObject * SWIG_globals(void)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *self, PyObject *args)
#define SWIG_OK
SWIGINTERN PyObject * _wrap_plbox(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args)
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#define SWIGINTERNINLINE
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *self, PyObject *args)
enum callback_type pltr_type
SWIGINTERN PyObject * _wrap_plaxes(PyObject *self, PyObject *args)
#define Py_TYPE(op)
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
#define MY_UNBLOCK_THREADS
#define SWIGRUNTIMEINLINE
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
char string[PL_MAXKEY]
Definition plplot.h:440
PLINT nx
Definition plplot.h:521
PLFLT_NC_MATRIX xg
Definition plplot.h:520
PLINT ny
Definition plplot.h:521
PLFLT_NC_MATRIX yg
Definition plplot.h:520
PLFLT_NC_FE_POINTER xg
Definition plplot.h:508
PLFLT_NC_FE_POINTER yg
Definition plplot.h:508
PLINT nx
Definition plplot.h:509
PLINT ny
Definition plplot.h:509
PyObject_HEAD void * ptr
swig_type_info * ty
swig_type_info * ty
PyObject_HEAD void * pack
swig_type_info * type
struct swig_cast_info * prev
struct swig_cast_info * next
swig_converter_func converter
swig_type_info ** ptype
PyObject *(* get_attr)(void)
struct swig_globalvar * next
int(* set_attr)(PyObject *)
swig_type_info ** types
swig_cast_info ** cast_initial
swig_type_info ** type_initial
struct swig_module_info * next
swig_dycast_func dcast
struct swig_cast_info * cast
PyObject_HEAD swig_globalvar * vars
static char buf[200]
Definition tclAPI.c:873
static tclMatrixXtnsnDescr * tail
Definition tclMatrix.c:461
static const char * name
Definition tkMain.c:135