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.4.0
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 0x040400
11#define SWIGPYTHON
12#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14#define SWIG_name "_plplotc"
15/* -----------------------------------------------------------------------------
16 * This section contains generic SWIG labels for method/variable
17 * declarations/attributes, and other compiler dependent labels.
18 * ----------------------------------------------------------------------------- */
19
20/* template workaround for compilers that cannot correctly implement the C++ standard */
21#ifndef SWIGTEMPLATEDISAMBIGUATOR
22# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
23# define SWIGTEMPLATEDISAMBIGUATOR template
24# elif defined(__HP_aCC)
25/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
26/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
27# define SWIGTEMPLATEDISAMBIGUATOR template
28# else
29# define SWIGTEMPLATEDISAMBIGUATOR
30# endif
31#endif
32
33/* inline attribute */
34#ifndef SWIGINLINE
35# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
36# define SWIGINLINE inline
37# else
38# define SWIGINLINE
39# endif
40#endif
41
42/* attribute recognised by some compilers to avoid 'unused' warnings */
43#ifndef SWIGUNUSED
44# if defined(__GNUC__)
45# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
46# define SWIGUNUSED __attribute__ ((__unused__))
47# else
48# define SWIGUNUSED
49# endif
50# elif defined(__ICC)
51# define SWIGUNUSED __attribute__ ((__unused__))
52# else
53# define SWIGUNUSED
54# endif
55#endif
56
57#ifndef SWIG_MSC_UNSUPPRESS_4505
58# if defined(_MSC_VER)
59# pragma warning(disable : 4505) /* unreferenced local function has been removed */
60# endif
61#endif
62
63#ifndef SWIGUNUSEDPARM
64# ifdef __cplusplus
65# define SWIGUNUSEDPARM(p)
66# else
67# define SWIGUNUSEDPARM(p) p SWIGUNUSED
68# endif
69#endif
70
71/* internal SWIG method */
72#ifndef SWIGINTERN
73# define SWIGINTERN static SWIGUNUSED
74#endif
75
76/* internal inline SWIG method */
77#ifndef SWIGINTERNINLINE
78# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
79#endif
80
81/* exporting methods */
82#if defined(__GNUC__)
83# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
84# ifndef GCC_HASCLASSVISIBILITY
85# define GCC_HASCLASSVISIBILITY
86# endif
87# endif
88#endif
89
90#ifndef SWIGEXPORT
91# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
92# if defined(STATIC_LINKED)
93# define SWIGEXPORT
94# else
95# define SWIGEXPORT __declspec(dllexport)
96# endif
97# else
98# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
99# define SWIGEXPORT __attribute__ ((visibility("default")))
100# else
101# define SWIGEXPORT
102# endif
103# endif
104#endif
105
106/* calling conventions for Windows */
107#ifndef SWIGSTDCALL
108# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
109# define SWIGSTDCALL __stdcall
110# else
111# define SWIGSTDCALL
112# endif
113#endif
114
115/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
116#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
117# define _CRT_SECURE_NO_DEPRECATE
118#endif
119
120/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
121#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
122# define _SCL_SECURE_NO_DEPRECATE
123#endif
124
125/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
126#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
127# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
128#endif
129
130/* Intel's compiler complains if a variable which was never initialised is
131 * cast to void, which is a common idiom which we use to indicate that we
132 * are aware a variable isn't used. So we just silence that warning.
133 * See: https://github.com/swig/swig/issues/192 for more discussion.
134 */
135#ifdef __INTEL_COMPILER
136# pragma warning disable 592
137#endif
138
139#if defined(__cplusplus) && __cplusplus >=201103L
140# define SWIG_NULLPTR nullptr
141#else
142# define SWIG_NULLPTR NULL
143#endif
144
145/* -----------------------------------------------------------------------------
146 * swigcompat.swg
147 *
148 * Macros to provide support compatibility with older C and C++ standards.
149 *
150 * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard.
151 * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option.
152 * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus.
153 * ----------------------------------------------------------------------------- */
154
155/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
156 * if you're missing it.
157 */
158#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
159 (defined __cplusplus && __cplusplus >= 201103L) || \
160 defined SWIG_HAVE_SNPRINTF) && \
161 !defined SWIG_NO_SNPRINTF
162# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
163# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
164#else
165/* Fallback versions ignore the buffer size, but most of our uses either have a
166 * fixed maximum possible size or dynamically allocate a buffer that's large
167 * enough.
168 */
169# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
170# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
171#endif
172
173
174#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
175/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
176# include <math.h>
177#endif
178
179#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
180#define PY_SSIZE_T_CLEAN
181#endif
182
183#if __GNUC__ >= 7
184#pragma GCC diagnostic push
185#if defined(__cplusplus) && __cplusplus >=201703L
186#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
187#endif
188#endif
189
190#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
191/* Use debug wrappers with the Python release dll */
192
193#if defined(_MSC_VER) && _MSC_VER >= 1929
194/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
195 * See https://github.com/swig/swig/issues/2090 */
196# include <corecrt.h>
197#endif
198
199# undef _DEBUG
200# include <Python.h>
201# define _DEBUG 1
202#else
203# include <Python.h>
204#endif
205
206#if !defined(SWIGPYTHON_BUILTIN) && PY_VERSION_HEX >= 0x03030000
207# define SWIG_HEAPTYPES
208
209/* Note: Currently this won't activate - it is in place ready for when the
210 * SWIGPYTHON_BUILTIN condition above gets removed. */
211# if PY_VERSION_HEX < 0x030c0000 && defined(SWIGPYTHON_BUILTIN)
212# include <structmember.h>
213# define Py_READONLY READONLY
214# define Py_T_PYSSIZET T_PYSSIZET
215# endif
216#endif
217
218#if __GNUC__ >= 7
219#pragma GCC diagnostic pop
220#endif
221
222#include <stdio.h>
223#include <stdlib.h>
224
225/* -----------------------------------------------------------------------------
226 * swigrun.swg
227 *
228 * This file contains generic C API SWIG runtime support for pointer
229 * type checking.
230 * ----------------------------------------------------------------------------- */
231
232/* This should only be incremented when either the layout of swig_type_info changes,
233 or for whatever reason, the runtime changes incompatibly */
234#define SWIG_RUNTIME_VERSION "4"
235
236/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
237#ifdef SWIG_TYPE_TABLE
238# define SWIG_QUOTE_STRING(x) #x
239# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
240# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
241#else
242# define SWIG_TYPE_TABLE_NAME
243#endif
244
245/*
246 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
247 creating a static or dynamic library from the SWIG runtime code.
248 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
249
250 But only do this if strictly necessary, ie, if you have problems
251 with your compiler or suchlike.
252*/
253
254#ifndef SWIGRUNTIME
255# define SWIGRUNTIME SWIGINTERN
256#endif
257
258#ifndef SWIGRUNTIMEINLINE
259# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
260#endif
261
262/* Generic buffer size */
263#ifndef SWIG_BUFFER_SIZE
264# define SWIG_BUFFER_SIZE 1024
265#endif
266
267/* Flags for pointer conversions */
268#define SWIG_POINTER_DISOWN 0x1
269#define SWIG_CAST_NEW_MEMORY 0x2
270#define SWIG_POINTER_NO_NULL 0x4
271#define SWIG_POINTER_CLEAR 0x8
272#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
273
274/* Flags for new pointer objects */
275#define SWIG_POINTER_OWN 0x1
276
277
278/*
279 Flags/methods for returning states.
280
281 The SWIG conversion methods, as ConvertPtr, return an integer
282 that tells if the conversion was successful or not. And if not,
283 an error code can be returned (see swigerrors.swg for the codes).
284
285 Use the following macros/flags to set or process the returning
286 states.
287
288 In old versions of SWIG, code such as the following was usually written:
289
290 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
291 // success code
292 } else {
293 //fail code
294 }
295
296 Now you can be more explicit:
297
298 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
299 if (SWIG_IsOK(res)) {
300 // success code
301 } else {
302 // fail code
303 }
304
305 which is the same really, but now you can also do
306
307 Type *ptr;
308 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
309 if (SWIG_IsOK(res)) {
310 // success code
311 if (SWIG_IsNewObj(res) {
312 ...
313 delete *ptr;
314 } else {
315 ...
316 }
317 } else {
318 // fail code
319 }
320
321 I.e., now SWIG_ConvertPtr can return new objects and you can
322 identify the case and take care of the deallocation. Of course that
323 also requires SWIG_ConvertPtr to return new result values, such as
324
325 int SWIG_ConvertPtr(obj, ptr,...) {
326 if (<obj is ok>) {
327 if (<need new object>) {
328 *ptr = <ptr to new allocated object>;
329 return SWIG_NEWOBJ;
330 } else {
331 *ptr = <ptr to old object>;
332 return SWIG_OLDOBJ;
333 }
334 } else {
335 return SWIG_BADOBJ;
336 }
337 }
338
339 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
340 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
341 SWIG errors code.
342
343 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
344 allows returning the 'cast rank', for example, if you have this
345
346 int food(double)
347 int fooi(int);
348
349 and you call
350
351 food(1) // cast rank '1' (1 -> 1.0)
352 fooi(1) // cast rank '0'
353
354 just use the SWIG_AddCast()/SWIG_CheckState()
355*/
356
357#define SWIG_OK (0)
358/* Runtime errors are < 0 */
359#define SWIG_ERROR (-1)
360/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
361/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
362/* Errors < -200 are generic runtime specific errors */
363#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
364
365#define SWIG_IsOK(r) (r >= 0)
366#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
367
368/* The CastRankLimit says how many bits are used for the cast rank */
369#define SWIG_CASTRANKLIMIT (1 << 8)
370/* The NewMask denotes the object was created (using new/malloc) */
371#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
372/* The TmpMask is for in/out typemaps that use temporary objects */
373#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
374/* Simple returning values */
375#define SWIG_BADOBJ (SWIG_ERROR)
376#define SWIG_OLDOBJ (SWIG_OK)
377#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
378#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
379/* Check, add and del object mask methods */
380#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
381#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
382#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
383#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
384#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
385#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
386
387/* Cast-Rank Mode */
388#if defined(SWIG_CASTRANK_MODE)
389# ifndef SWIG_TypeRank
390# define SWIG_TypeRank unsigned long
391# endif
392# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
393# define SWIG_MAXCASTRANK (2)
394# endif
395# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
396# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
398 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
399}
401 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
402}
403#else /* no cast-rank mode */
404# define SWIG_AddCast(r) (r)
405# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
406#endif
407
408
409#include <string.h>
410
411#ifdef __cplusplus
412extern "C" {
413#endif
414
415typedef void *(*swig_converter_func)(void *, int *);
416typedef struct swig_type_info *(*swig_dycast_func)(void **);
417
418/* Structure to store information on one type */
419typedef struct swig_type_info {
420 const char *name; /* mangled name of this type */
421 const char *str; /* human readable name of this type */
422 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
423 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
424 void *clientdata; /* language specific type data */
425 int owndata; /* flag if the structure owns the clientdata */
427
428/* Structure to store a type and conversion function used for casting */
429typedef struct swig_cast_info {
430 swig_type_info *type; /* pointer to type that is equivalent to this type */
431 swig_converter_func converter; /* function to cast the void pointers */
432 struct swig_cast_info *next; /* pointer to next cast in linked list */
433 struct swig_cast_info *prev; /* pointer to the previous cast */
435
436/* Structure used to store module information
437 * Each module generates one structure like this, and the runtime collects
438 * all of these structures and stores them in a circularly linked list.*/
439typedef struct swig_module_info {
440 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
441 size_t size; /* Number of types in this module */
442 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
443 swig_type_info **type_initial; /* Array of initially generated type structures */
444 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
445 void *clientdata; /* Language specific module data */
447
448/*
449 Compare two type names skipping the space characters, therefore
450 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
451
452 Return 0 when the two name types are equivalent, as in
453 strncmp, but skipping ' '.
454*/
455SWIGRUNTIME int
456SWIG_TypeNameComp(const char *f1, const char *l1,
457 const char *f2, const char *l2) {
458 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
459 while ((*f1 == ' ') && (f1 != l1)) ++f1;
460 while ((*f2 == ' ') && (f2 != l2)) ++f2;
461 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
462 }
463 return (int)((l1 - f1) - (l2 - f2));
464}
465
466/*
467 Check type equivalence in a name list like <name1>|<name2>|...
468 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
469*/
470SWIGRUNTIME int
471SWIG_TypeCmp(const char *nb, const char *tb) {
472 int equiv = 1;
473 const char* te = tb + strlen(tb);
474 const char* ne = nb;
475 while (equiv != 0 && *ne) {
476 for (nb = ne; *ne; ++ne) {
477 if (*ne == '|') break;
478 }
479 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
480 if (*ne) ++ne;
481 }
482 return equiv;
483}
484
485/*
486 Check type equivalence in a name list like <name1>|<name2>|...
487 Return 0 if not equal, 1 if equal
488*/
489SWIGRUNTIME int
490SWIG_TypeEquiv(const char *nb, const char *tb) {
491 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
492}
493
494/*
495 Check the typename
496*/
498SWIG_TypeCheck(const char *c, swig_type_info *ty) {
499 if (ty) {
500 swig_cast_info *iter = ty->cast;
501 while (iter) {
502 if (strcmp(iter->type->name, c) == 0) {
503 if (iter == ty->cast)
504 return iter;
505 /* Move iter to the top of the linked list */
506 iter->prev->next = iter->next;
507 if (iter->next)
508 iter->next->prev = iter->prev;
509 iter->next = ty->cast;
510 iter->prev = 0;
511 if (ty->cast) ty->cast->prev = iter;
512 ty->cast = iter;
513 return iter;
514 }
515 iter = iter->next;
516 }
517 }
518 return 0;
519}
520
521/*
522 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
523*/
526 if (ty) {
527 swig_cast_info *iter = ty->cast;
528 while (iter) {
529 if (iter->type == from) {
530 if (iter == ty->cast)
531 return iter;
532 /* Move iter to the top of the linked list */
533 iter->prev->next = iter->next;
534 if (iter->next)
535 iter->next->prev = iter->prev;
536 iter->next = ty->cast;
537 iter->prev = 0;
538 if (ty->cast) ty->cast->prev = iter;
539 ty->cast = iter;
540 return iter;
541 }
542 iter = iter->next;
543 }
544 }
545 return 0;
546}
547
548/*
549 Cast a pointer up an inheritance hierarchy
550*/
552SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
553 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
554}
555
556/*
557 Dynamic pointer casting. Down an inheritance hierarchy
558*/
561 swig_type_info *lastty = ty;
562 if (!ty || !ty->dcast) return ty;
563 while (ty && (ty->dcast)) {
564 ty = (*ty->dcast)(ptr);
565 if (ty) lastty = ty;
566 }
567 return lastty;
568}
569
570/*
571 Return the name associated with this type
572*/
573SWIGRUNTIMEINLINE const char *
575 return ty->name;
576}
577
578/*
579 Return the pretty name associated with this type,
580 that is an unmangled type name in a form presentable to the user.
581*/
582SWIGRUNTIME const char *
584 /* The "str" field contains the equivalent pretty names of the
585 type, separated by vertical-bar characters. Choose the last
586 name. It should be the most specific; a fully resolved name
587 but not necessarily with default template parameters expanded. */
588 if (!type) return NULL;
589 if (type->str != NULL) {
590 const char *last_name = type->str;
591 const char *s;
592 for (s = type->str; *s; s++)
593 if (*s == '|') last_name = s+1;
594 return last_name;
595 }
596 else
597 return type->name;
598}
599
600/*
601 Set the clientdata field for a type
602*/
603SWIGRUNTIME void
605 swig_cast_info *cast = ti->cast;
606 /* if (ti->clientdata == clientdata) return; */
608
609 while (cast) {
610 if (!cast->converter) {
611 swig_type_info *tc = cast->type;
612 if (!tc->clientdata) {
614 }
615 }
616 cast = cast->next;
617 }
618}
619SWIGRUNTIME void
624
625/*
626 Search for a swig_type_info structure only by mangled name
627 Search is a O(log #types)
628
629 We start searching at module start, and finish searching when start == end.
630 Note: if start == end at the beginning of the function, we go all the way around
631 the circular list.
632*/
635 swig_module_info *end,
636 const char *name) {
637 swig_module_info *iter = start;
638 do {
639 if (iter->size) {
640 size_t l = 0;
641 size_t r = iter->size - 1;
642 do {
643 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
644 size_t i = (l + r) >> 1;
645 const char *iname = iter->types[i]->name;
646 if (iname) {
647 int compare = strcmp(name, iname);
648 if (compare == 0) {
649 return iter->types[i];
650 } else if (compare < 0) {
651 if (i) {
652 r = i - 1;
653 } else {
654 break;
655 }
656 } else if (compare > 0) {
657 l = i + 1;
658 }
659 } else {
660 break; /* should never happen */
661 }
662 } while (l <= r);
663 }
664 iter = iter->next;
665 } while (iter != end);
666 return 0;
667}
668
669/*
670 Search for a swig_type_info structure for either a mangled name or a human readable name.
671 It first searches the mangled names of the types, which is a O(log #types)
672 If a type is not found it then searches the human readable names, which is O(#types).
673
674 We start searching at module start, and finish searching when start == end.
675 Note: if start == end at the beginning of the function, we go all the way around
676 the circular list.
677*/
680 swig_module_info *end,
681 const char *name) {
682 /* STEP 1: Search the name field using binary search */
684 if (ret) {
685 return ret;
686 } else {
687 /* STEP 2: If the type hasn't been found, do a complete search
688 of the str field (the human readable name) */
689 swig_module_info *iter = start;
690 do {
691 size_t i = 0;
692 for (; i < iter->size; ++i) {
693 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
694 return iter->types[i];
695 }
696 iter = iter->next;
697 } while (iter != end);
698 }
699
700 /* neither found a match */
701 return 0;
702}
703
704/*
705 Pack binary data into a string
706*/
707SWIGRUNTIME char *
708SWIG_PackData(char *c, void *ptr, size_t sz) {
709 static const char hex[17] = "0123456789abcdef";
710 const unsigned char *u = (unsigned char *) ptr;
711 const unsigned char *eu = u + sz;
712 for (; u != eu; ++u) {
713 unsigned char uu = *u;
714 *(c++) = hex[(uu & 0xf0) >> 4];
715 *(c++) = hex[uu & 0xf];
716 }
717 return c;
718}
719
720/*
721 Unpack binary data from a string
722*/
723SWIGRUNTIME const char *
724SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
725 unsigned char *u = (unsigned char *) ptr;
726 const unsigned char *eu = u + sz;
727 for (; u != eu; ++u) {
728 char d = *(c++);
729 unsigned char uu;
730 if ((d >= '0') && (d <= '9'))
731 uu = (unsigned char)((d - '0') << 4);
732 else if ((d >= 'a') && (d <= 'f'))
733 uu = (unsigned char)((d - ('a'-10)) << 4);
734 else
735 return (char *) 0;
736 d = *(c++);
737 if ((d >= '0') && (d <= '9'))
738 uu |= (unsigned char)(d - '0');
739 else if ((d >= 'a') && (d <= 'f'))
740 uu |= (unsigned char)(d - ('a'-10));
741 else
742 return (char *) 0;
743 *u = uu;
744 }
745 return c;
746}
747
748/*
749 Pack 'void *' into a string buffer.
750*/
751SWIGRUNTIME char *
752SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
753 char *r = buff;
754 if ((2*sizeof(void *) + 2) > bsz) return 0;
755 *(r++) = '_';
756 r = SWIG_PackData(r,&ptr,sizeof(void *));
757 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
758 strcpy(r,name);
759 return buff;
760}
761
762SWIGRUNTIME const char *
763SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
764 if (*c != '_') {
765 if (strcmp(c,"NULL") == 0) {
766 *ptr = (void *) 0;
767 return name;
768 } else {
769 return 0;
770 }
771 }
772 return SWIG_UnpackData(++c,ptr,sizeof(void *));
773}
774
775SWIGRUNTIME char *
776SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
777 char *r = buff;
778 size_t lname = (name ? strlen(name) : 0);
779 if ((2*sz + 2 + lname) > bsz) return 0;
780 *(r++) = '_';
781 r = SWIG_PackData(r,ptr,sz);
782 if (lname) {
783 strncpy(r,name,lname+1);
784 } else {
785 *r = 0;
786 }
787 return buff;
788}
789
790SWIGRUNTIME const char *
791SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
792 if (*c != '_') {
793 if (strcmp(c,"NULL") == 0) {
794 memset(ptr,0,sz);
795 return name;
796 } else {
797 return 0;
798 }
799 }
800 return SWIG_UnpackData(++c,ptr,sz);
801}
802
803#ifdef __cplusplus
804}
805#endif
806
807/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
808#define SWIG_UnknownError -1
809#define SWIG_IOError -2
810#define SWIG_RuntimeError -3
811#define SWIG_IndexError -4
812#define SWIG_TypeError -5
813#define SWIG_DivisionByZero -6
814#define SWIG_OverflowError -7
815#define SWIG_SyntaxError -8
816#define SWIG_ValueError -9
817#define SWIG_SystemError -10
818#define SWIG_AttributeError -11
819#define SWIG_MemoryError -12
820#define SWIG_NullReferenceError -13
821
822
823/* Compatibility macros for Python 3 */
824#if PY_VERSION_HEX >= 0x03000000
825
826#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
827#define PyInt_Check(x) PyLong_Check(x)
828#define PyInt_AsLong(x) PyLong_AsLong(x)
829#define PyInt_FromLong(x) PyLong_FromLong(x)
830#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
831#define PyString_Check(name) PyBytes_Check(name)
832#define PyString_FromString(x) PyUnicode_FromString(x)
833#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
834#define PyString_AsString(str) PyBytes_AsString(str)
835#define PyString_Size(str) PyBytes_Size(str)
836#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
837#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
838#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
839
840#endif
841
842/* SWIG APIs for compatibility of both Python 2 & 3 */
843
844#if PY_VERSION_HEX >= 0x03000000
845# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
846#else
847# define SWIG_Python_str_FromFormat PyString_FromFormat
848#endif
849
850
851/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */
852SWIGINTERN const char *
853SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
854{
855#if PY_VERSION_HEX >= 0x03030000
856# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
857 *pbytes = NULL;
858 return PyUnicode_AsUTF8AndSize(str, psize);
859# else
860 const char *chars;
861 *pbytes = PyUnicode_AsUTF8String(str);
862 chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL;
863 if (chars && psize)
864 *psize = PyBytes_Size(*pbytes);
865 return chars;
866# endif
867#else
868 char *chars = NULL;
869 *pbytes = NULL;
870 PyString_AsStringAndSize(str, &chars, psize);
871 return chars;
872#endif
873}
874
875SWIGINTERN PyObject*
877{
878#if PY_VERSION_HEX >= 0x03000000
879 return PyUnicode_FromString(c);
880#else
881 return PyString_FromString(c);
882#endif
883}
884
885/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
886# define SWIGPY_USE_CAPSULE
887#ifdef SWIGPYTHON_BUILTIN
888# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
889#else
890# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
891#endif
892# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
893
894#if PY_VERSION_HEX < 0x03020000
895#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
896#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
897#define Py_hash_t long
898#endif
899
900#ifdef Py_LIMITED_API
901# define PyTuple_GET_ITEM PyTuple_GetItem
902/* 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
903 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. */
904# define PyTuple_SET_ITEM PyTuple_SetItem
905# define PyTuple_GET_SIZE PyTuple_Size
906# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
907# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
908# define PyCFunction_GET_SELF PyCFunction_GetSelf
909# define PyList_GET_ITEM PyList_GetItem
910# define PyList_SET_ITEM PyList_SetItem
911# define PySliceObject PyObject
912#endif
913
914/* Increment and Decrement wrappers - for portability when using the stable abi and for performance otherwise */
915#ifdef Py_LIMITED_API
916# define SWIG_Py_INCREF Py_IncRef
917# define SWIG_Py_XINCREF Py_IncRef
918# define SWIG_Py_DECREF Py_DecRef
919# define SWIG_Py_XDECREF Py_DecRef
920#else
921# define SWIG_Py_INCREF Py_INCREF
922# define SWIG_Py_XINCREF Py_XINCREF
923# define SWIG_Py_DECREF Py_DECREF
924# define SWIG_Py_XDECREF Py_XDECREF
925#endif
926
927/* -----------------------------------------------------------------------------
928 * error manipulation
929 * ----------------------------------------------------------------------------- */
930
931SWIGRUNTIME PyObject*
933 PyObject* type = 0;
934 switch(code) {
935 case SWIG_MemoryError:
936 type = PyExc_MemoryError;
937 break;
938 case SWIG_IOError:
939 type = PyExc_IOError;
940 break;
942 type = PyExc_RuntimeError;
943 break;
944 case SWIG_IndexError:
945 type = PyExc_IndexError;
946 break;
947 case SWIG_TypeError:
948 type = PyExc_TypeError;
949 break;
951 type = PyExc_ZeroDivisionError;
952 break;
954 type = PyExc_OverflowError;
955 break;
956 case SWIG_SyntaxError:
957 type = PyExc_SyntaxError;
958 break;
959 case SWIG_ValueError:
960 type = PyExc_ValueError;
961 break;
962 case SWIG_SystemError:
963 type = PyExc_SystemError;
964 break;
966 type = PyExc_AttributeError;
967 break;
969 type = PyExc_TypeError;
970 break;
971 default:
972 type = PyExc_RuntimeError;
973 }
974 return type;
975}
976
977
978SWIGRUNTIME void
979SWIG_Python_AddErrorMsg(const char* mesg)
980{
981 PyObject *type = 0;
982 PyObject *value = 0;
983 PyObject *traceback = 0;
984
985 if (PyErr_Occurred())
986 PyErr_Fetch(&type, &value, &traceback);
987 if (value) {
988 PyObject *old_str = PyObject_Str(value);
989 PyObject *bytes = NULL;
990 const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
991 PyErr_Clear();
992 SWIG_Py_XINCREF(type);
993 if (tmp)
994 PyErr_Format(type, "%s %s", tmp, mesg);
995 else
996 PyErr_Format(type, "%s", mesg);
997 SWIG_Py_XDECREF(bytes);
998 SWIG_Py_DECREF(old_str);
1000 } else {
1001 PyErr_SetString(PyExc_RuntimeError, mesg);
1002 }
1003}
1004
1005SWIGRUNTIME int
1007{
1008 PyObject *error;
1009 if (obj)
1010 return 0;
1011 error = PyErr_Occurred();
1012 return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
1013}
1014
1015SWIGRUNTIME void
1017{
1019 /* Use existing TypeError to preserve stacktrace and enhance with given message */
1020 PyObject *newvalue;
1021 PyObject *type = NULL, *value = NULL, *traceback = NULL;
1022 PyErr_Fetch(&type, &value, &traceback);
1023#if PY_VERSION_HEX >= 0x03000000
1024 newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
1025#else
1026 newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
1027#endif
1028 if (newvalue) {
1030 PyErr_Restore(type, newvalue, traceback);
1031 } else {
1032 PyErr_Restore(type, value, traceback);
1033 }
1034 } else {
1035 /* Raise TypeError using given message */
1036 PyErr_SetString(PyExc_TypeError, message);
1037 }
1038}
1039
1040#if defined(SWIG_PYTHON_NO_THREADS)
1041# if defined(SWIG_PYTHON_THREADS)
1042# undef SWIG_PYTHON_THREADS
1043# endif
1044#endif
1045#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1046# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1047# define SWIG_PYTHON_USE_GIL
1048# endif
1049# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1050# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1051# if PY_VERSION_HEX < 0x03070000
1052# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1053# else
1054# define SWIG_PYTHON_INITIALIZE_THREADS
1055# endif
1056# endif
1057# ifdef __cplusplus /* C++ code */
1058 class SWIG_Python_Thread_Block {
1059 bool status;
1060 PyGILState_STATE state;
1061 public:
1062 void end() { if (status) { PyGILState_Release(state); status = false;} }
1063 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1064 ~SWIG_Python_Thread_Block() { end(); }
1065 };
1066 class SWIG_Python_Thread_Allow {
1067 bool status;
1068 PyThreadState *save;
1069 public:
1070 void end() { if (status) { status = false; PyEval_RestoreThread(save); }}
1071 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1072 ~SWIG_Python_Thread_Allow() { end(); }
1073 };
1074# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1075# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1076# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1077# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1078# else /* C code */
1079# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1080# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1081# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1082# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1083# endif
1084# else /* Old thread way, not implemented, user must provide it */
1085# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1086# define SWIG_PYTHON_INITIALIZE_THREADS
1087# endif
1088# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1089# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1090# endif
1091# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1092# define SWIG_PYTHON_THREAD_END_BLOCK
1093# endif
1094# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1095# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1096# endif
1097# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1098# define SWIG_PYTHON_THREAD_END_ALLOW
1099# endif
1100# endif
1101#else /* No thread support */
1102# define SWIG_PYTHON_INITIALIZE_THREADS
1103# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1104# define SWIG_PYTHON_THREAD_END_BLOCK
1105# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1106# define SWIG_PYTHON_THREAD_END_ALLOW
1107#endif
1108
1109/* -----------------------------------------------------------------------------
1110 * Python API portion that goes into the runtime
1111 * ----------------------------------------------------------------------------- */
1112
1113#ifdef __cplusplus
1114extern "C" {
1115#endif
1116
1117/* -----------------------------------------------------------------------------
1118 * Constant declarations
1119 * ----------------------------------------------------------------------------- */
1120
1121/* Constant Types */
1122#define SWIG_PY_POINTER 4
1123#define SWIG_PY_BINARY 5
1124
1125/* Constant information structure */
1134
1135#ifdef __cplusplus
1136}
1137#endif
1138
1139
1140/* -----------------------------------------------------------------------------
1141 * pyrun.swg
1142 *
1143 * This file contains the runtime support for Python modules
1144 * and includes code for managing global variables and pointer
1145 * type checking.
1146 *
1147 * ----------------------------------------------------------------------------- */
1148
1149#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
1150# error "This version of SWIG only supports Python >= 2.7"
1151#endif
1152
1153#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
1154# error "This version of SWIG only supports Python 3 >= 3.3"
1155#endif
1156
1157/* Common SWIG API */
1158
1159/* for raw pointers */
1160#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1161#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1162#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1163
1164#ifdef SWIGPYTHON_BUILTIN
1165#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1166#else
1167#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1168#endif
1169
1170#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1171
1172#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1173#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1174#define swig_owntype int
1175
1176/* for raw packed data */
1177#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1178#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1179
1180/* for class or struct pointers */
1181#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1182#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1183
1184/* for C or C++ function pointers */
1185#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1186#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1187
1188/* for C++ member pointers, ie, member methods */
1189#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1190#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1191
1192
1193/* Runtime API */
1194
1195#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1196#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1197#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1198
1199#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1200#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1201#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1202#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1203#define SWIG_fail goto fail
1204
1205
1206/* Runtime API implementation */
1207
1208/* Error manipulation */
1209
1210SWIGINTERN void
1211SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1213 PyErr_SetObject(errtype, obj);
1214 SWIG_Py_DECREF(obj);
1216}
1217
1218SWIGINTERN void
1219SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1221 PyErr_SetString(errtype, msg);
1223}
1224
1225#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1226
1227/* Set a constant value */
1228
1229#if defined(SWIGPYTHON_BUILTIN)
1230
1231SWIGINTERN void
1232SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1233 PyObject *s = PyString_InternFromString(key);
1234 PyList_Append(seq, s);
1235 SWIG_Py_DECREF(s);
1236}
1237
1238SWIGINTERN void
1239SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1240 PyDict_SetItemString(d, name, obj);
1241 SWIG_Py_DECREF(obj);
1242 if (public_interface)
1243 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1244}
1245
1246#else
1247
1248SWIGINTERN void
1249SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1250 PyDict_SetItemString(d, name, obj);
1251 SWIG_Py_DECREF(obj);
1252}
1253
1254#endif
1255
1256/* Append a value to the result obj */
1257
1258SWIGINTERN PyObject*
1259SWIG_Python_AppendOutput(PyObject* result, PyObject* obj, int is_void) {
1260 if (!result) {
1261 result = obj;
1262 } else if (result == Py_None && is_void) {
1263 SWIG_Py_DECREF(result);
1264 result = obj;
1265 } else {
1266 if (!PyList_Check(result)) {
1267 PyObject *o2 = result;
1268 result = PyList_New(1);
1269 if (result) {
1270 PyList_SET_ITEM(result, 0, o2);
1271 } else {
1272 SWIG_Py_DECREF(obj);
1273 return o2;
1274 }
1275 }
1276 PyList_Append(result,obj);
1277 SWIG_Py_DECREF(obj);
1278 }
1279 return result;
1280}
1281
1282/* Unpack the argument tuple */
1283
1284SWIGINTERN Py_ssize_t
1285SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1286{
1287 if (!args) {
1288 if (!min && !max) {
1289 return 1;
1290 } else {
1291 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1292 name, (min == max ? "" : "at least "), (int)min);
1293 return 0;
1294 }
1295 }
1296 if (!PyTuple_Check(args)) {
1297 if (min <= 1 && max >= 1) {
1298 Py_ssize_t i;
1299 objs[0] = args;
1300 for (i = 1; i < max; ++i) {
1301 objs[i] = 0;
1302 }
1303 return 2;
1304 }
1305 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1306 return 0;
1307 } else {
1308 Py_ssize_t l = PyTuple_GET_SIZE(args);
1309 if (l < min) {
1310 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1311 name, (min == max ? "" : "at least "), (int)min, (int)l);
1312 return 0;
1313 } else if (l > max) {
1314 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1315 name, (min == max ? "" : "at most "), (int)max, (int)l);
1316 return 0;
1317 } else {
1318 Py_ssize_t i;
1319 for (i = 0; i < l; ++i) {
1320 objs[i] = PyTuple_GET_ITEM(args, i);
1321 }
1322 for (; l < max; ++l) {
1323 objs[l] = 0;
1324 }
1325 return i + 1;
1326 }
1327 }
1328}
1329
1330SWIGINTERN int
1331SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
1332 int no_kwargs = 1;
1333 if (kwargs) {
1334 assert(PyDict_Check(kwargs));
1335 if (PyDict_Size(kwargs) > 0) {
1336 PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
1337 no_kwargs = 0;
1338 }
1339 }
1340 return no_kwargs;
1341}
1342
1343/* A functor is a function object with one single object argument */
1344#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1345
1346/*
1347 Helper for static pointer initialization for both C and C++ code, for example
1348 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1349*/
1350#ifdef __cplusplus
1351#define SWIG_STATIC_POINTER(var) var
1352#else
1353#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1354#endif
1355
1356#ifdef __cplusplus
1357extern "C" {
1358#endif
1359
1360/* Python-specific SWIG API */
1361#define SWIG_newvarlink() SWIG_Python_newvarlink()
1362#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
1363#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
1364
1365/* -----------------------------------------------------------------------------
1366 * global variable support code.
1367 * ----------------------------------------------------------------------------- */
1368
1369typedef struct swig_globalvar {
1370 char *name; /* Name of global variable */
1371 PyObject *(*get_attr)(void); /* Return the current value */
1372 int (*set_attr)(PyObject *); /* Set the value */
1375
1380
1381SWIGINTERN PyObject *
1383#if PY_VERSION_HEX >= 0x03000000
1384 return PyUnicode_InternFromString("<Swig global variables>");
1385#else
1386 return PyString_FromString("<Swig global variables>");
1387#endif
1388}
1389
1390SWIGINTERN PyObject *
1391swig_varlink_str(PyObject *o) {
1393#if PY_VERSION_HEX >= 0x03000000
1394 PyObject *str = PyUnicode_InternFromString("(");
1395 PyObject *tail;
1396 PyObject *joined;
1397 swig_globalvar *var;
1398 for (var = v->vars; var; var=var->next) {
1399 tail = PyUnicode_FromString(var->name);
1400 joined = PyUnicode_Concat(str, tail);
1401 SWIG_Py_DECREF(str);
1403 str = joined;
1404 if (var->next) {
1405 tail = PyUnicode_InternFromString(", ");
1406 joined = PyUnicode_Concat(str, tail);
1407 SWIG_Py_DECREF(str);
1409 str = joined;
1410 }
1411 }
1412 tail = PyUnicode_InternFromString(")");
1413 joined = PyUnicode_Concat(str, tail);
1414 SWIG_Py_DECREF(str);
1416 str = joined;
1417#else
1418 PyObject *str = PyString_FromString("(");
1419 swig_globalvar *var;
1420 for (var = v->vars; var; var=var->next) {
1421 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
1422 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
1423 }
1424 PyString_ConcatAndDel(&str,PyString_FromString(")"));
1425#endif
1426 return str;
1427}
1428
1429SWIGINTERN void
1432 swig_globalvar *var = v->vars;
1433 while (var) {
1434 swig_globalvar *n = var->next;
1435 free(var->name);
1436 free(var);
1437 var = n;
1438 }
1439}
1440
1441SWIGINTERN PyObject *
1442swig_varlink_getattr(PyObject *o, char *n) {
1444 PyObject *res = NULL;
1445 swig_globalvar *var = v->vars;
1446 while (var) {
1447 if (strcmp(var->name,n) == 0) {
1448 res = (*var->get_attr)();
1449 break;
1450 }
1451 var = var->next;
1452 }
1453 if (res == NULL && !PyErr_Occurred()) {
1454 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
1455 }
1456 return res;
1457}
1458
1459SWIGINTERN int
1460swig_varlink_setattr(PyObject *o, char *n, PyObject *p) {
1462 int res = 1;
1463 swig_globalvar *var = v->vars;
1464 while (var) {
1465 if (strcmp(var->name,n) == 0) {
1466 res = (*var->set_attr)(p);
1467 break;
1468 }
1469 var = var->next;
1470 }
1471 if (res == 1 && !PyErr_Occurred()) {
1472 PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
1473 }
1474 return res;
1475}
1476
1477SWIGINTERN PyTypeObject*
1479 static char varlink__doc__[] = "Swig var link object";
1480#ifndef SWIG_HEAPTYPES
1481 static PyTypeObject varlink_type;
1482 static int type_init = 0;
1483 if (!type_init) {
1484 const PyTypeObject tmp = {
1485#if PY_VERSION_HEX >= 0x03000000
1486 PyVarObject_HEAD_INIT(NULL, 0)
1487#else
1488 PyObject_HEAD_INIT(NULL)
1489 0, /* ob_size */
1490#endif
1491 "swigvarlink", /* tp_name */
1492 sizeof(swig_varlinkobject), /* tp_basicsize */
1493 0, /* tp_itemsize */
1494 (destructor) swig_varlink_dealloc, /* tp_dealloc */
1495#if PY_VERSION_HEX < 0x030800b4
1496 (printfunc)0, /* tp_print */
1497#else
1498 (Py_ssize_t)0, /* tp_vectorcall_offset */
1499#endif
1500 (getattrfunc) swig_varlink_getattr, /* tp_getattr */
1501 (setattrfunc) swig_varlink_setattr, /* tp_setattr */
1502 0, /* tp_compare */
1503 (reprfunc) swig_varlink_repr, /* tp_repr */
1504 0, /* tp_as_number */
1505 0, /* tp_as_sequence */
1506 0, /* tp_as_mapping */
1507 0, /* tp_hash */
1508 0, /* tp_call */
1509 (reprfunc) swig_varlink_str, /* tp_str */
1510 0, /* tp_getattro */
1511 0, /* tp_setattro */
1512 0, /* tp_as_buffer */
1513 0, /* tp_flags */
1514 varlink__doc__, /* tp_doc */
1515 0, /* tp_traverse */
1516 0, /* tp_clear */
1517 0, /* tp_richcompare */
1518 0, /* tp_weaklistoffset */
1519 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
1520 0, /* tp_del */
1521 0, /* tp_version_tag */
1522#if PY_VERSION_HEX >= 0x03040000
1523 0, /* tp_finalize */
1524#endif
1525#if PY_VERSION_HEX >= 0x03080000
1526 0, /* tp_vectorcall */
1527#endif
1528#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
1529 0, /* tp_print */
1530#endif
1531#if PY_VERSION_HEX >= 0x030c0000
1532 0, /* tp_watched */
1533#endif
1534#if PY_VERSION_HEX >= 0x030d00a4
1535 0, /* tp_versions_used */
1536#endif
1537#ifdef COUNT_ALLOCS
1538 0, /* tp_allocs */
1539 0, /* tp_frees */
1540 0, /* tp_maxalloc */
1541 0, /* tp_prev */
1542 0 /* tp_next */
1543#endif
1544 };
1545 varlink_type = tmp;
1546 type_init = 1;
1547 if (PyType_Ready(&varlink_type) < 0)
1548 return NULL;
1549 }
1550 return &varlink_type;
1551#else
1552 PyType_Slot slots[] = {
1553 { Py_tp_dealloc, (void *)swig_varlink_dealloc },
1554 { Py_tp_repr, (void *)swig_varlink_repr },
1555 { Py_tp_getattr, (void *)swig_varlink_getattr },
1556 { Py_tp_setattr, (void *)swig_varlink_setattr },
1557 { Py_tp_str, (void *)swig_varlink_str },
1558 { Py_tp_doc, (void *)varlink__doc__ },
1559 { 0, NULL }
1560 };
1561 PyType_Spec spec = {
1562 "swigvarlink",
1563 sizeof(swig_varlinkobject),
1564 0,
1565 Py_TPFLAGS_DEFAULT,
1566 slots
1567 };
1568 return (PyTypeObject *)PyType_FromSpec(&spec);
1569#endif
1570}
1571
1572/* Create a variable linking object for use later */
1573SWIGINTERN PyObject *
1575 swig_varlinkobject *result = PyObject_New(swig_varlinkobject, swig_varlink_type());
1576 if (result) {
1577 result->vars = 0;
1578 }
1579 return ((PyObject*) result);
1580}
1581
1582SWIGINTERN void
1583SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
1585 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
1586 if (gv) {
1587 size_t size = strlen(name)+1;
1588 gv->name = (char *)malloc(size);
1589 if (gv->name) {
1590 memcpy(gv->name, name, size);
1591 gv->get_attr = get_attr;
1592 gv->set_attr = set_attr;
1593 gv->next = v->vars;
1594 }
1595 }
1596 v->vars = gv;
1597}
1598
1599
1600static PyObject *Swig_Globals_global = NULL;
1601
1602SWIGINTERN PyObject *
1604 if (Swig_Globals_global == NULL) {
1606 }
1607 return Swig_Globals_global;
1608}
1609
1610#ifdef __cplusplus
1611}
1612#endif
1613
1614/* -----------------------------------------------------------------------------
1615 * Pointer declarations
1616 * ----------------------------------------------------------------------------- */
1617
1618/* Flags for new pointer objects */
1619#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1620#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1621
1622#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1623
1624#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1625#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1626
1627#ifdef __cplusplus
1628extern "C" {
1629#endif
1630
1631/* The python void return value */
1632
1633SWIGRUNTIMEINLINE PyObject *
1635{
1636 PyObject *none = Py_None;
1637 SWIG_Py_INCREF(none);
1638 return none;
1639}
1640
1641/* SwigPyClientData */
1642
1643typedef struct {
1644 PyObject *klass;
1645 PyObject *newraw;
1646 PyObject *newargs;
1647 PyObject *destroy;
1650 PyTypeObject *pytype;
1652
1655{
1657 int fail = data ? data->implicitconv : 0;
1658 if (fail)
1659 PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
1660 return fail;
1661}
1662
1663SWIGRUNTIMEINLINE PyObject *
1665 SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1666 PyObject *klass = data ? data->klass : 0;
1667 return (klass ? klass : PyExc_RuntimeError);
1668}
1669
1670
1673{
1674 if (!obj) {
1675 return 0;
1676 } else {
1677 SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1678 /* the klass element */
1679 data->klass = obj;
1680 SWIG_Py_INCREF(data->klass);
1681 /* the newraw method and newargs arguments used to create a new raw instance */
1682 if (PyClass_Check(obj)) {
1683 data->newraw = 0;
1684 SWIG_Py_INCREF(obj);
1685 data->newargs = obj;
1686 } else {
1687 data->newraw = PyObject_GetAttrString(data->klass, "__new__");
1688 if (data->newraw) {
1689 data->newargs = PyTuple_New(1);
1690 if (data->newargs) {
1691 SWIG_Py_INCREF(obj);
1692 PyTuple_SET_ITEM(data->newargs, 0, obj);
1693 } else {
1694 SWIG_Py_DECREF(data->newraw);
1695 SWIG_Py_DECREF(data->klass);
1696 free(data);
1697 return 0;
1698 }
1699 } else {
1700 SWIG_Py_INCREF(obj);
1701 data->newargs = obj;
1702 }
1703 }
1704 /* the destroy method, aka as the C++ delete method */
1705 data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
1706 if (PyErr_Occurred()) {
1707 PyErr_Clear();
1708 data->destroy = 0;
1709 }
1710 if (data->destroy) {
1711 data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
1712 } else {
1713 data->delargs = 0;
1714 }
1715 data->implicitconv = 0;
1716 data->pytype = 0;
1717 return data;
1718 }
1719}
1720
1721SWIGRUNTIME void
1723{
1724 SWIG_Py_XDECREF(data->klass);
1725 SWIG_Py_XDECREF(data->newraw);
1726 SWIG_Py_XDECREF(data->newargs);
1727 SWIG_Py_XDECREF(data->destroy);
1728 free(data);
1729}
1730
1731/* =============== SwigPyObject =====================*/
1732
1733typedef struct {
1734 PyObject_HEAD
1735 void *ptr;
1737 int own;
1738 PyObject *next;
1739#ifdef SWIGPYTHON_BUILTIN
1740 PyObject *dict;
1741#endif
1742} SwigPyObject;
1743
1744
1745#ifdef SWIGPYTHON_BUILTIN
1746
1747SWIGRUNTIME PyObject *
1748SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1749{
1750 SwigPyObject *sobj = (SwigPyObject *)v;
1751
1752 if (!sobj->dict)
1753 sobj->dict = PyDict_New();
1754
1755 SWIG_Py_XINCREF(sobj->dict);
1756 return sobj->dict;
1757}
1758
1759#endif
1760
1761SWIGRUNTIME PyObject *
1763{
1764 return PyLong_FromVoidPtr(v->ptr);
1765}
1766
1767SWIGRUNTIME PyObject *
1769{
1770 PyObject *res = NULL;
1771 PyObject *args = PyTuple_New(1);
1772 if (args) {
1773 PyObject *val = SwigPyObject_long(v);
1774 if (val) {
1775 PyObject *ofmt;
1776 PyTuple_SET_ITEM(args, 0, val);
1777 ofmt = SWIG_Python_str_FromChar(fmt);
1778 if (ofmt) {
1779#if PY_VERSION_HEX >= 0x03000000
1780 res = PyUnicode_Format(ofmt,args);
1781#else
1782 res = PyString_Format(ofmt,args);
1783#endif
1784 SWIG_Py_DECREF(ofmt);
1785 }
1786 }
1787 SWIG_Py_DECREF(args);
1788 }
1789 return res;
1790}
1791
1792SWIGRUNTIME PyObject *
1794{
1795 return SwigPyObject_format("%o",v);
1796}
1797
1798SWIGRUNTIME PyObject *
1800{
1801 return SwigPyObject_format("%x",v);
1802}
1803
1804SWIGRUNTIME PyObject *
1806{
1807 const char *name = SWIG_TypePrettyName(v->ty);
1808 PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1809 if (repr && v->next) {
1810 PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1811 if (nrep) {
1812# if PY_VERSION_HEX >= 0x03000000
1813 PyObject *joined = PyUnicode_Concat(repr, nrep);
1814 SWIG_Py_DECREF(repr);
1815 SWIG_Py_DECREF(nrep);
1816 repr = joined;
1817# else
1818 PyString_ConcatAndDel(&repr,nrep);
1819# endif
1820 } else {
1821 SWIG_Py_DECREF(repr);
1822 repr = NULL;
1823 }
1824 }
1825 return repr;
1826}
1827
1828/* We need a version taking two PyObject* parameters so it's a valid
1829 * PyCFunction to use in swigobject_methods[]. */
1830SWIGRUNTIME PyObject *
1831SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1832{
1833 return SwigPyObject_repr((SwigPyObject*)v);
1834}
1835
1836SWIGRUNTIME int
1838{
1839 void *i = v->ptr;
1840 void *j = w->ptr;
1841 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1842}
1843
1844/* Added for Python 3.x, would it also be useful for Python 2.x? */
1845SWIGRUNTIME PyObject*
1847{
1848 PyObject* res = NULL;
1849 if (!PyErr_Occurred()) {
1850 if (op != Py_EQ && op != Py_NE) {
1851 SWIG_Py_INCREF(Py_NotImplemented);
1852 return Py_NotImplemented;
1853 }
1854 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1855 }
1856 return res;
1857}
1858
1859
1860SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1861
1862#ifdef SWIGPYTHON_BUILTIN
1863static swig_type_info *SwigPyObject_stype = 0;
1864SWIGRUNTIME PyTypeObject*
1865SwigPyObject_type(void) {
1866 SwigPyClientData *cd;
1867 assert(SwigPyObject_stype);
1868 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1869 assert(cd);
1870 assert(cd->pytype);
1871 return cd->pytype;
1872}
1873#else
1874SWIGRUNTIME PyTypeObject*
1876 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1877 return type;
1878}
1879#endif
1880
1882SwigPyObject_Check(PyObject *op) {
1883 PyTypeObject *target_tp = SwigPyObject_type();
1884 PyTypeObject *op_type = Py_TYPE(op);
1885#ifdef SWIGPYTHON_BUILTIN
1886 if (PyType_IsSubtype(op_type, target_tp))
1887 return 1;
1888 return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
1889#else
1890# ifdef Py_LIMITED_API
1891 int cmp;
1892 PyObject *tp_name;
1893#endif
1894 if (op_type == target_tp)
1895 return 1;
1896# ifdef Py_LIMITED_API
1897 tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
1898 if (!tp_name)
1899 return 0;
1900 cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyObject");
1901 SWIG_Py_DECREF(tp_name);
1902 return cmp == 0;
1903# else
1904 return (strcmp(op_type->tp_name, "SwigPyObject") == 0);
1905# endif
1906#endif
1907}
1908
1909SWIGRUNTIME PyObject *
1910SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1911
1912static PyObject* Swig_Capsule_global = NULL;
1913
1914SWIGRUNTIME void
1916{
1917 SwigPyObject *sobj = (SwigPyObject *) v;
1918 PyObject *next = sobj->next;
1919 if (sobj->own == SWIG_POINTER_OWN) {
1920 swig_type_info *ty = sobj->ty;
1921 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1922 PyObject *destroy = data ? data->destroy : 0;
1923 if (destroy) {
1924 /* destroy is always a VARARGS method */
1925 PyObject *res;
1926
1927 /* PyObject_CallFunction() has the potential to silently drop
1928 the active exception. In cases of unnamed temporary
1929 variable or where we just finished iterating over a generator
1930 StopIteration will be active right now, and this needs to
1931 remain true upon return from SwigPyObject_dealloc. So save
1932 and restore. */
1933
1934 PyObject *type = NULL, *value = NULL, *traceback = NULL;
1935 PyErr_Fetch(&type, &value, &traceback);
1936
1937 if (data->delargs) {
1938 /* we need to create a temporary object to carry the destroy operation */
1939 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1940 if (tmp) {
1941 res = SWIG_Python_CallFunctor(destroy, tmp);
1942 } else {
1943 res = 0;
1944 }
1945 SWIG_Py_XDECREF(tmp);
1946 } else {
1947 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1948 PyObject *mself = PyCFunction_GET_SELF(destroy);
1949 res = ((*meth)(mself, v));
1950 }
1951 if (!res)
1952 PyErr_WriteUnraisable(destroy);
1953
1954 PyErr_Restore(type, value, traceback);
1955
1956 SWIG_Py_XDECREF(res);
1957 }
1958#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1959 else {
1960 const char *name = SWIG_TypePrettyName(ty);
1961 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1962 }
1963#endif
1965 }
1966 SWIG_Py_XDECREF(next);
1967#ifdef SWIGPYTHON_BUILTIN
1968 SWIG_Py_XDECREF(sobj->dict);
1969#endif
1970 PyObject_Free(v);
1971}
1972
1973SWIGRUNTIME PyObject*
1974SwigPyObject_append(PyObject* v, PyObject* next)
1975{
1976 SwigPyObject *sobj = (SwigPyObject *) v;
1977 if (!SwigPyObject_Check(next)) {
1978 PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1979 return NULL;
1980 }
1981 ((SwigPyObject *)next)->next = sobj->next;
1982 sobj->next = next;
1983 SWIG_Py_INCREF(next);
1984 return SWIG_Py_Void();
1985}
1986
1987SWIGRUNTIME PyObject*
1988SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1989{
1990 SwigPyObject *sobj = (SwigPyObject *) v;
1991 if (sobj->next) {
1992 SWIG_Py_INCREF(sobj->next);
1993 return sobj->next;
1994 } else {
1995 return SWIG_Py_Void();
1996 }
1997}
1998
1999SWIGINTERN PyObject*
2000SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
2001{
2002 SwigPyObject *sobj = (SwigPyObject *)v;
2003 sobj->own = 0;
2004 return SWIG_Py_Void();
2005}
2006
2007SWIGINTERN PyObject*
2008SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
2009{
2010 SwigPyObject *sobj = (SwigPyObject *)v;
2011 sobj->own = SWIG_POINTER_OWN;
2012 return SWIG_Py_Void();
2013}
2014
2015SWIGINTERN PyObject*
2016SwigPyObject_own(PyObject *v, PyObject *args)
2017{
2018 PyObject *val = 0;
2019 if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
2020 return NULL;
2021 } else {
2022 SwigPyObject *sobj = (SwigPyObject *)v;
2023 PyObject *obj = PyBool_FromLong(sobj->own);
2024 if (val) {
2025 if (PyObject_IsTrue(val)) {
2027 } else {
2029 }
2030 }
2031 return obj;
2032 }
2033}
2034
2035static PyMethodDef
2037 {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
2038 {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
2039 {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
2040 {"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
2041 {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
2042 {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
2043 {0, 0, 0, 0}
2044};
2045
2046SWIGRUNTIME PyTypeObject*
2048 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
2049#ifndef SWIG_HEAPTYPES
2050 static PyNumberMethods SwigPyObject_as_number = {
2051 (binaryfunc)0, /*nb_add*/
2052 (binaryfunc)0, /*nb_subtract*/
2053 (binaryfunc)0, /*nb_multiply*/
2054 /* nb_divide removed in Python 3 */
2055#if PY_VERSION_HEX < 0x03000000
2056 (binaryfunc)0, /*nb_divide*/
2057#endif
2058 (binaryfunc)0, /*nb_remainder*/
2059 (binaryfunc)0, /*nb_divmod*/
2060 (ternaryfunc)0,/*nb_power*/
2061 (unaryfunc)0, /*nb_negative*/
2062 (unaryfunc)0, /*nb_positive*/
2063 (unaryfunc)0, /*nb_absolute*/
2064 (inquiry)0, /*nb_nonzero*/
2065 0, /*nb_invert*/
2066 0, /*nb_lshift*/
2067 0, /*nb_rshift*/
2068 0, /*nb_and*/
2069 0, /*nb_xor*/
2070 0, /*nb_or*/
2071#if PY_VERSION_HEX < 0x03000000
2072 0, /*nb_coerce*/
2073#endif
2074 (unaryfunc)SwigPyObject_long, /*nb_int*/
2075#if PY_VERSION_HEX < 0x03000000
2076 (unaryfunc)SwigPyObject_long, /*nb_long*/
2077#else
2078 0, /*nb_reserved*/
2079#endif
2080 (unaryfunc)0, /*nb_float*/
2081#if PY_VERSION_HEX < 0x03000000
2082 (unaryfunc)SwigPyObject_oct, /*nb_oct*/
2083 (unaryfunc)SwigPyObject_hex, /*nb_hex*/
2084#endif
2085#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
2086 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
2087#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
2088 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
2089#else
2090 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
2091#endif
2092 };
2093
2094 static PyTypeObject swigpyobject_type;
2095 static int type_init = 0;
2096 if (!type_init) {
2097 const PyTypeObject tmp = {
2098#if PY_VERSION_HEX >= 0x03000000
2099 PyVarObject_HEAD_INIT(NULL, 0)
2100#else
2101 PyObject_HEAD_INIT(NULL)
2102 0, /* ob_size */
2103#endif
2104 "SwigPyObject", /* tp_name */
2105 sizeof(SwigPyObject), /* tp_basicsize */
2106 0, /* tp_itemsize */
2107 (destructor)SwigPyObject_dealloc, /* tp_dealloc */
2108#if PY_VERSION_HEX < 0x030800b4
2109 (printfunc)0, /* tp_print */
2110#else
2111 (Py_ssize_t)0, /* tp_vectorcall_offset */
2112#endif
2113 (getattrfunc)0, /* tp_getattr */
2114 (setattrfunc)0, /* tp_setattr */
2115#if PY_VERSION_HEX >= 0x03000000
2116 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
2117#else
2118 (cmpfunc)SwigPyObject_compare, /* tp_compare */
2119#endif
2120 (reprfunc)SwigPyObject_repr, /* tp_repr */
2121 &SwigPyObject_as_number, /* tp_as_number */
2122 0, /* tp_as_sequence */
2123 0, /* tp_as_mapping */
2124 (hashfunc)0, /* tp_hash */
2125 (ternaryfunc)0, /* tp_call */
2126 0, /* tp_str */
2127 PyObject_GenericGetAttr, /* tp_getattro */
2128 0, /* tp_setattro */
2129 0, /* tp_as_buffer */
2130 Py_TPFLAGS_DEFAULT, /* tp_flags */
2131 swigobject_doc, /* tp_doc */
2132 0, /* tp_traverse */
2133 0, /* tp_clear */
2134 (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
2135 0, /* tp_weaklistoffset */
2136 0, /* tp_iter */
2137 0, /* tp_iternext */
2138 swigobject_methods, /* tp_methods */
2139 0, /* tp_members */
2140 0, /* tp_getset */
2141 0, /* tp_base */
2142 0, /* tp_dict */
2143 0, /* tp_descr_get */
2144 0, /* tp_descr_set */
2145 0, /* tp_dictoffset */
2146 0, /* tp_init */
2147 0, /* tp_alloc */
2148 0, /* tp_new */
2149 0, /* tp_free */
2150 0, /* tp_is_gc */
2151 0, /* tp_bases */
2152 0, /* tp_mro */
2153 0, /* tp_cache */
2154 0, /* tp_subclasses */
2155 0, /* tp_weaklist */
2156 0, /* tp_del */
2157 0, /* tp_version_tag */
2158#if PY_VERSION_HEX >= 0x03040000
2159 0, /* tp_finalize */
2160#endif
2161#if PY_VERSION_HEX >= 0x03080000
2162 0, /* tp_vectorcall */
2163#endif
2164#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2165 0, /* tp_print */
2166#endif
2167#if PY_VERSION_HEX >= 0x030c0000
2168 0, /* tp_watched */
2169#endif
2170#if PY_VERSION_HEX >= 0x030d00a4
2171 0, /* tp_versions_used */
2172#endif
2173#ifdef COUNT_ALLOCS
2174 0, /* tp_allocs */
2175 0, /* tp_frees */
2176 0, /* tp_maxalloc */
2177 0, /* tp_prev */
2178 0 /* tp_next */
2179#endif
2180 };
2181 swigpyobject_type = tmp;
2182 type_init = 1;
2183 if (PyType_Ready(&swigpyobject_type) != 0)
2184 return NULL;
2185 }
2186 return &swigpyobject_type;
2187#else
2188 PyType_Slot slots[] = {
2189 { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
2190 { Py_tp_repr, (void *)SwigPyObject_repr },
2191 { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
2192 { Py_tp_doc, (void *)swigobject_doc },
2193 { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
2194 { Py_tp_methods, (void *)swigobject_methods },
2195 { Py_nb_int, (void *)SwigPyObject_long },
2196 { 0, NULL }
2197 };
2198 PyType_Spec spec = {
2199 "SwigPyObject",
2200 sizeof(SwigPyObject),
2201 0,
2202 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
2203 slots
2204 };
2205 return (PyTypeObject *)PyType_FromSpec(&spec);
2206#endif
2207}
2208
2209SWIGRUNTIME PyObject *
2210SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2211{
2212 SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_type());
2213 if (sobj) {
2214 sobj->ptr = ptr;
2215 sobj->ty = ty;
2216 sobj->own = own;
2217 sobj->next = 0;
2218#ifdef SWIGPYTHON_BUILTIN
2219 sobj->dict = 0;
2220#endif
2221 if (own == SWIG_POINTER_OWN) {
2222 /* Obtain a reference to the Python capsule wrapping the module information, so that the
2223 * module information is correctly destroyed after all SWIG python objects have been freed
2224 * by the GC (and corresponding destructors invoked) */
2226 }
2227 }
2228 return (PyObject *)sobj;
2229}
2230
2231/* -----------------------------------------------------------------------------
2232 * Implements a simple Swig Packed type, and use it instead of string
2233 * ----------------------------------------------------------------------------- */
2234
2235typedef struct {
2236 PyObject_HEAD
2237 void *pack;
2239 size_t size;
2240} SwigPyPacked;
2241
2242SWIGRUNTIME PyObject *
2244{
2245 char result[SWIG_BUFFER_SIZE];
2246 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2247 return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2248 } else {
2249 return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2250 }
2251}
2252
2253SWIGRUNTIME PyObject *
2255{
2256 char result[SWIG_BUFFER_SIZE];
2257 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2258 return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2259 } else {
2260 return SWIG_Python_str_FromChar(v->ty->name);
2261 }
2262}
2263
2264SWIGRUNTIME int
2266{
2267 size_t i = v->size;
2268 size_t j = w->size;
2269 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2270 return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
2271}
2272
2273SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2274
2275SWIGRUNTIME PyTypeObject*
2277 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2278 return type;
2279}
2280
2282SwigPyPacked_Check(PyObject *op) {
2283#ifdef Py_LIMITED_API
2284 int cmp;
2285 PyObject *tp_name;
2286#endif
2287 PyTypeObject* op_type = Py_TYPE(op);
2288 if (op_type == SwigPyPacked_TypeOnce())
2289 return 1;
2290#ifdef Py_LIMITED_API
2291 tp_name = PyObject_GetAttrString((PyObject *)op_type, "__name__");
2292 if (!tp_name)
2293 return 0;
2294 cmp = PyUnicode_CompareWithASCIIString(tp_name, "SwigPyPacked");
2295 SWIG_Py_DECREF(tp_name);
2296 return cmp == 0;
2297#else
2298 return (strcmp(op_type->tp_name, "SwigPyPacked") == 0);
2299#endif
2300}
2301
2302SWIGRUNTIME void
2304{
2305 if (SwigPyPacked_Check(v)) {
2306 SwigPyPacked *sobj = (SwigPyPacked *) v;
2307 free(sobj->pack);
2308 }
2309 PyObject_Free(v);
2310}
2311
2312SWIGRUNTIME PyTypeObject*
2314 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2315#ifndef SWIG_HEAPTYPES
2316 static PyTypeObject swigpypacked_type;
2317 static int type_init = 0;
2318 if (!type_init) {
2319 const PyTypeObject tmp = {
2320#if PY_VERSION_HEX>=0x03000000
2321 PyVarObject_HEAD_INIT(NULL, 0)
2322#else
2323 PyObject_HEAD_INIT(NULL)
2324 0, /* ob_size */
2325#endif
2326 "SwigPyPacked", /* tp_name */
2327 sizeof(SwigPyPacked), /* tp_basicsize */
2328 0, /* tp_itemsize */
2329 (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2330#if PY_VERSION_HEX < 0x030800b4
2331 (printfunc)0, /* tp_print */
2332#else
2333 (Py_ssize_t)0, /* tp_vectorcall_offset */
2334#endif
2335 (getattrfunc)0, /* tp_getattr */
2336 (setattrfunc)0, /* tp_setattr */
2337#if PY_VERSION_HEX>=0x03000000
2338 0, /* tp_reserved in 3.0.1 */
2339#else
2340 (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2341#endif
2342 (reprfunc)SwigPyPacked_repr, /* tp_repr */
2343 0, /* tp_as_number */
2344 0, /* tp_as_sequence */
2345 0, /* tp_as_mapping */
2346 (hashfunc)0, /* tp_hash */
2347 (ternaryfunc)0, /* tp_call */
2348 (reprfunc)SwigPyPacked_str, /* tp_str */
2349 PyObject_GenericGetAttr, /* tp_getattro */
2350 0, /* tp_setattro */
2351 0, /* tp_as_buffer */
2352 Py_TPFLAGS_DEFAULT, /* tp_flags */
2353 swigpacked_doc, /* tp_doc */
2354 0, /* tp_traverse */
2355 0, /* tp_clear */
2356 0, /* tp_richcompare */
2357 0, /* tp_weaklistoffset */
2358 0, /* tp_iter */
2359 0, /* tp_iternext */
2360 0, /* tp_methods */
2361 0, /* tp_members */
2362 0, /* tp_getset */
2363 0, /* tp_base */
2364 0, /* tp_dict */
2365 0, /* tp_descr_get */
2366 0, /* tp_descr_set */
2367 0, /* tp_dictoffset */
2368 0, /* tp_init */
2369 0, /* tp_alloc */
2370 0, /* tp_new */
2371 0, /* tp_free */
2372 0, /* tp_is_gc */
2373 0, /* tp_bases */
2374 0, /* tp_mro */
2375 0, /* tp_cache */
2376 0, /* tp_subclasses */
2377 0, /* tp_weaklist */
2378 0, /* tp_del */
2379 0, /* tp_version_tag */
2380#if PY_VERSION_HEX >= 0x03040000
2381 0, /* tp_finalize */
2382#endif
2383#if PY_VERSION_HEX >= 0x03080000
2384 0, /* tp_vectorcall */
2385#endif
2386#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2387 0, /* tp_print */
2388#endif
2389#if PY_VERSION_HEX >= 0x030c0000
2390 0, /* tp_watched */
2391#endif
2392#if PY_VERSION_HEX >= 0x030d00a4
2393 0, /* tp_versions_used */
2394#endif
2395#ifdef COUNT_ALLOCS
2396 0, /* tp_allocs */
2397 0, /* tp_frees */
2398 0, /* tp_maxalloc */
2399 0, /* tp_prev */
2400 0 /* tp_next */
2401#endif
2402 };
2403 swigpypacked_type = tmp;
2404 type_init = 1;
2405 if (PyType_Ready(&swigpypacked_type) != 0)
2406 return NULL;
2407 }
2408 return &swigpypacked_type;
2409#else
2410 PyType_Slot slots[] = {
2411 { Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
2412 { Py_tp_repr, (void *)SwigPyPacked_repr },
2413 { Py_tp_str, (void *)SwigPyPacked_str },
2414 { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
2415 { Py_tp_doc, (void *)swigpacked_doc },
2416 { 0, NULL }
2417 };
2418 PyType_Spec spec = {
2419 "SwigPyPacked",
2420 sizeof(SwigPyPacked),
2421 0,
2422 Py_TPFLAGS_DEFAULT,
2423 slots
2424 };
2425 return (PyTypeObject *)PyType_FromSpec(&spec);
2426#endif
2427}
2428
2429SWIGRUNTIME PyObject *
2430SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2431{
2432 SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_type());
2433 if (sobj) {
2434 void *pack = malloc(size);
2435 if (pack) {
2436 memcpy(pack, ptr, size);
2437 sobj->pack = pack;
2438 sobj->ty = ty;
2439 sobj->size = size;
2440 } else {
2441 PyObject_Free((PyObject *)sobj);
2442 sobj = 0;
2443 }
2444 }
2445 return (PyObject *) sobj;
2446}
2447
2449SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2450{
2451 if (SwigPyPacked_Check(obj)) {
2452 SwigPyPacked *sobj = (SwigPyPacked *)obj;
2453 if (sobj->size != size) return 0;
2454 memcpy(ptr, sobj->pack, size);
2455 return sobj->ty;
2456 } else {
2457 return 0;
2458 }
2459}
2460
2461/* -----------------------------------------------------------------------------
2462 * pointers/data manipulation
2463 * ----------------------------------------------------------------------------- */
2464
2465static PyObject *Swig_This_global = NULL;
2466
2467SWIGRUNTIME PyObject *
2469{
2470 if (Swig_This_global == NULL)
2472 return Swig_This_global;
2473}
2474
2475/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2476
2477/* TODO: I don't know how to implement the fast getset in Python 3 right now */
2478#if PY_VERSION_HEX>=0x03000000
2479#define SWIG_PYTHON_SLOW_GETSET_THIS
2480#endif
2481
2484{
2485 PyObject *obj;
2486
2487 if (SwigPyObject_Check(pyobj))
2488 return (SwigPyObject *) pyobj;
2489
2490#ifdef SWIGPYTHON_BUILTIN
2491 (void)obj;
2492# ifdef PyWeakref_CheckProxy
2493 if (PyWeakref_CheckProxy(pyobj)) {
2494#if PY_VERSION_HEX >= 0x030d0000
2495 PyWeakref_GetRef(pyobj, &pyobj);
2496 Py_DECREF(pyobj);
2497#else
2498 pyobj = PyWeakref_GET_OBJECT(pyobj);
2499#endif
2500 if (pyobj && SwigPyObject_Check(pyobj))
2501 return (SwigPyObject*) pyobj;
2502 }
2503# endif
2504 return NULL;
2505#else
2506
2507 obj = 0;
2508
2509#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2510 if (PyInstance_Check(pyobj)) {
2511 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2512 } else {
2513 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2514 if (dictptr != NULL) {
2515 PyObject *dict = *dictptr;
2516 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2517 } else {
2518#ifdef PyWeakref_CheckProxy
2519 if (PyWeakref_CheckProxy(pyobj)) {
2520 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2521 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2522 }
2523#endif
2524 obj = PyObject_GetAttr(pyobj,SWIG_This());
2525 if (obj) {
2526 SWIG_Py_DECREF(obj);
2527 } else {
2528 if (PyErr_Occurred()) PyErr_Clear();
2529 return 0;
2530 }
2531 }
2532 }
2533#else
2534 obj = PyObject_GetAttr(pyobj,SWIG_This());
2535 if (obj) {
2536 SWIG_Py_DECREF(obj);
2537 } else {
2538 if (PyErr_Occurred()) PyErr_Clear();
2539 return 0;
2540 }
2541#endif
2542 if (obj && !SwigPyObject_Check(obj)) {
2543 /* a PyObject is called 'this', try to get the 'real this'
2544 SwigPyObject from it */
2545 return SWIG_Python_GetSwigThis(obj);
2546 }
2547 return (SwigPyObject *)obj;
2548#endif
2549}
2550
2551/* Acquire a pointer value */
2552
2553SWIGRUNTIME int
2554SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2555 if (own == SWIG_POINTER_OWN) {
2557 if (sobj) {
2558 int oldown = sobj->own;
2559 sobj->own = own;
2560 return oldown;
2561 }
2562 }
2563 return 0;
2564}
2565
2566/* Convert a pointer value */
2567
2568SWIGRUNTIME int
2569SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2570 int res;
2571 SwigPyObject *sobj;
2572 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2573
2574 if (!obj)
2575 return SWIG_ERROR;
2576 if (obj == Py_None && !implicit_conv) {
2577 if (ptr)
2578 *ptr = 0;
2580 }
2581
2582 res = SWIG_ERROR;
2583
2584 sobj = SWIG_Python_GetSwigThis(obj);
2585 if (own)
2586 *own = 0;
2587 while (sobj) {
2588 void *vptr = sobj->ptr;
2589 if (ty) {
2590 swig_type_info *to = sobj->ty;
2591 if (to == ty) {
2592 /* no type cast needed */
2593 if (ptr) *ptr = vptr;
2594 break;
2595 } else {
2596 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2597 if (!tc) {
2598 sobj = (SwigPyObject *)sobj->next;
2599 } else {
2600 if (ptr) {
2601 int newmemory = 0;
2602 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2603 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2604 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2605 if (own)
2606 *own = *own | SWIG_CAST_NEW_MEMORY;
2607 }
2608 }
2609 break;
2610 }
2611 }
2612 } else {
2613 if (ptr) *ptr = vptr;
2614 break;
2615 }
2616 }
2617 if (sobj) {
2618 if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
2620 } else {
2621 if (own)
2622 *own = *own | sobj->own;
2623 if (flags & SWIG_POINTER_DISOWN) {
2624 sobj->own = 0;
2625 }
2626 if (flags & SWIG_POINTER_CLEAR) {
2627 sobj->ptr = 0;
2628 }
2629 res = SWIG_OK;
2630 }
2631 } else {
2632 if (implicit_conv) {
2633 SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2634 if (data && !data->implicitconv) {
2635 PyObject *klass = data->klass;
2636 if (klass) {
2637 PyObject *impconv;
2638 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2639 impconv = SWIG_Python_CallFunctor(klass, obj);
2640 data->implicitconv = 0;
2641 if (PyErr_Occurred()) {
2642 PyErr_Clear();
2643 impconv = 0;
2644 }
2645 if (impconv) {
2646 SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2647 if (iobj) {
2648 void *vptr;
2649 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2650 if (SWIG_IsOK(res)) {
2651 if (ptr) {
2652 *ptr = vptr;
2653 /* transfer the ownership to 'ptr' */
2654 iobj->own = 0;
2655 res = SWIG_AddCast(res);
2656 res = SWIG_AddNewMask(res);
2657 } else {
2658 res = SWIG_AddCast(res);
2659 }
2660 }
2661 }
2662 SWIG_Py_DECREF(impconv);
2663 }
2664 }
2665 }
2666 if (!SWIG_IsOK(res) && obj == Py_None) {
2667 if (ptr)
2668 *ptr = 0;
2669 if (PyErr_Occurred())
2670 PyErr_Clear();
2671 res = SWIG_OK;
2672 }
2673 }
2674 }
2675 return res;
2676}
2677
2678/* Convert a function ptr value */
2679
2680SWIGRUNTIME int
2681SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2682 if (!PyCFunction_Check(obj)) {
2683 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2684 } else {
2685 void *vptr = 0;
2686 swig_cast_info *tc;
2687
2688 /* here we get the method pointer for callbacks */
2689#ifndef Py_LIMITED_API
2690 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2691#else
2692 PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
2693 PyObject *bytes = NULL;
2694 const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
2695#endif
2696 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2697 if (desc)
2698 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2699#ifdef Py_LIMITED_API
2700 SWIG_Py_XDECREF(bytes);
2701 SWIG_Py_XDECREF(pystr_doc);
2702#endif
2703 if (!desc)
2704 return SWIG_ERROR;
2705 tc = SWIG_TypeCheck(desc,ty);
2706 if (tc) {
2707 int newmemory = 0;
2708 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2709 assert(!newmemory); /* newmemory handling not yet implemented */
2710 } else {
2711 return SWIG_ERROR;
2712 }
2713 return SWIG_OK;
2714 }
2715}
2716
2717/* Convert a packed pointer value */
2718
2719SWIGRUNTIME int
2720SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2721 swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2722 if (!to) return SWIG_ERROR;
2723 if (ty) {
2724 if (to != ty) {
2725 /* check type cast? */
2726 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2727 if (!tc) return SWIG_ERROR;
2728 }
2729 }
2730 return SWIG_OK;
2731}
2732
2733/* -----------------------------------------------------------------------------
2734 * Create a new pointer object
2735 * ----------------------------------------------------------------------------- */
2736
2737/*
2738 Create a new instance object, without calling __init__, and set the
2739 'this' attribute.
2740*/
2741
2742SWIGRUNTIME PyObject*
2744{
2745 PyObject *inst = 0;
2746 PyObject *newraw = data->newraw;
2747 if (newraw) {
2748 inst = PyObject_Call(newraw, data->newargs, NULL);
2749 if (inst) {
2750#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2751 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2752 if (dictptr != NULL) {
2753 PyObject *dict = *dictptr;
2754 if (dict == NULL) {
2755 dict = PyDict_New();
2756 *dictptr = dict;
2757 }
2758 if (dict) {
2759 PyDict_SetItem(dict, SWIG_This(), swig_this);
2760 } else{
2761 SWIG_Py_DECREF(inst);
2762 inst = 0;
2763 }
2764 }
2765#else
2766 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2767 SWIG_Py_DECREF(inst);
2768 inst = 0;
2769 }
2770#endif
2771 }
2772 } else {
2773#if PY_VERSION_HEX >= 0x03000000
2774 PyObject *empty_args = PyTuple_New(0);
2775 if (empty_args) {
2776 PyObject *empty_kwargs = PyDict_New();
2777 if (empty_kwargs) {
2778#ifndef Py_LIMITED_API
2779 newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
2780#else
2781 newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
2782#endif
2783 inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
2784 SWIG_Py_DECREF(empty_kwargs);
2785 if (inst) {
2786 if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
2787 SWIG_Py_DECREF(inst);
2788 inst = 0;
2789 } else {
2790 PyType_Modified(Py_TYPE(inst));
2791 }
2792 }
2793 }
2794 SWIG_Py_DECREF(empty_args);
2795 }
2796#else
2797 PyObject *dict = PyDict_New();
2798 if (dict) {
2799 PyDict_SetItem(dict, SWIG_This(), swig_this);
2800 inst = PyInstance_NewRaw(data->newargs, dict);
2801 SWIG_Py_DECREF(dict);
2802 }
2803#endif
2804 }
2805 return inst;
2806}
2807
2808SWIGRUNTIME int
2809SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2810{
2811#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2812 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2813 if (dictptr != NULL) {
2814 PyObject *dict = *dictptr;
2815 if (dict == NULL) {
2816 dict = PyDict_New();
2817 *dictptr = dict;
2818 }
2819 if (dict) {
2820 return PyDict_SetItem(dict, SWIG_This(), swig_this);
2821 } else{
2822 return -1;
2823 }
2824 }
2825#endif
2826 return PyObject_SetAttr(inst, SWIG_This(), swig_this);
2827}
2828
2829
2830SWIGINTERN PyObject *
2832 PyObject *obj[2];
2833 if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2834 return NULL;
2835 } else {
2836 SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2837 if (sthis) {
2838 SWIG_Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
2839 } else {
2840 if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
2841 return NULL;
2842 }
2843 return SWIG_Py_Void();
2844 }
2845}
2846
2847/* Create a new pointer object */
2848
2849SWIGRUNTIME PyObject *
2850SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2851 SwigPyClientData *clientdata;
2852 PyObject * robj;
2853 int own;
2854
2855 if (!ptr)
2856 return SWIG_Py_Void();
2857
2858 clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2859 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2860 if (clientdata && clientdata->pytype) {
2861 SwigPyObject *newobj;
2862 if (flags & SWIG_BUILTIN_TP_INIT) {
2863 newobj = (SwigPyObject*) self;
2864 if (newobj->ptr) {
2865#ifndef Py_LIMITED_API
2866 allocfunc alloc = clientdata->pytype->tp_alloc;
2867#else
2868 allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
2869#endif
2870 PyObject *next_self = alloc(clientdata->pytype, 0);
2871 while (newobj->next)
2872 newobj = (SwigPyObject *) newobj->next;
2873 newobj->next = next_self;
2874 newobj = (SwigPyObject *)next_self;
2875#ifdef SWIGPYTHON_BUILTIN
2876 newobj->dict = 0;
2877#endif
2878 }
2879 } else {
2880 newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2881#ifdef SWIGPYTHON_BUILTIN
2882 if (newobj) {
2883 newobj->dict = 0;
2884 }
2885#endif
2886 }
2887 if (newobj) {
2888 newobj->ptr = ptr;
2889 newobj->ty = type;
2890 newobj->own = own;
2891 newobj->next = 0;
2892 return (PyObject*) newobj;
2893 }
2894 return SWIG_Py_Void();
2895 }
2896
2897 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2898
2899 robj = SwigPyObject_New(ptr, type, own);
2900 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2901 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2902 SWIG_Py_DECREF(robj);
2903 robj = inst;
2904 }
2905 return robj;
2906}
2907
2908/* Create a new packed object */
2909
2910SWIGRUNTIMEINLINE PyObject *
2911SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2912 return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2913}
2914
2915/* -----------------------------------------------------------------------------*
2916 * Get type list
2917 * -----------------------------------------------------------------------------*/
2918
2919#ifdef SWIG_LINK_RUNTIME
2920void *SWIG_ReturnGlobalTypeList(void *);
2921#endif
2922
2923static PyObject *Swig_TypeCache_global = NULL;
2924
2925/* The python cached type query */
2926SWIGRUNTIME PyObject *
2928 if (Swig_TypeCache_global == NULL) {
2929 Swig_TypeCache_global = PyDict_New();
2930 }
2931 return Swig_TypeCache_global;
2932}
2933
2936#ifdef SWIG_LINK_RUNTIME
2937 static void *type_pointer = (void *)0;
2938 /* first check if module already created */
2939 if (!type_pointer) {
2940 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2941 }
2942#else
2943 void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2944 if (PyErr_Occurred()) {
2945 PyErr_Clear();
2946 type_pointer = (void *)0;
2947 }
2948#endif
2949 return (swig_module_info *) type_pointer;
2950}
2951
2952
2953static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */
2954
2955SWIGRUNTIME void
2957{
2958 swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2959 swig_type_info **types = swig_module->types;
2960 size_t i;
2961 if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
2962 return;
2963 for (i =0; i < swig_module->size; ++i) {
2964 swig_type_info *ty = types[i];
2965 if (ty->owndata) {
2967 ty->clientdata = 0;
2968 if (data) SwigPyClientData_Del(data);
2969 }
2970 }
2972 Swig_This_global = NULL;
2974 Swig_Globals_global = NULL;
2976 Swig_TypeCache_global = NULL;
2977 Swig_Capsule_global = NULL;
2978}
2979
2980SWIGRUNTIME void
2982#if PY_VERSION_HEX >= 0x03000000
2983 /* Add a dummy module object into sys.modules */
2984 PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2985#else
2986 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2987 PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2988#endif
2989 PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2990 if (pointer && module) {
2991 if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
2993 Swig_Capsule_global = pointer;
2994 } else {
2995 SWIG_Py_DECREF(pointer);
2996 }
2997 } else {
2998 SWIG_Py_XDECREF(pointer);
2999 }
3000}
3001
3003SWIG_Python_TypeQuery(const char *type)
3004{
3005 PyObject *cache = SWIG_Python_TypeCache();
3006 PyObject *key = SWIG_Python_str_FromChar(type);
3007 PyObject *obj = PyDict_GetItem(cache, key);
3008 swig_type_info *descriptor;
3009 if (obj) {
3010 descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
3011 } else {
3013 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
3014 if (descriptor) {
3015 obj = PyCapsule_New((void*) descriptor, NULL, NULL);
3016 if (obj) {
3017 PyDict_SetItem(cache, key, obj);
3018 SWIG_Py_DECREF(obj);
3019 }
3020 }
3021 }
3022 SWIG_Py_DECREF(key);
3023 return descriptor;
3024}
3025
3026/*
3027 For backward compatibility only
3028*/
3029#define SWIG_POINTER_EXCEPTION 0
3030#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
3031#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
3032
3033SWIGRUNTIME int
3034SWIG_Python_AddErrMesg(const char* mesg, int infront)
3035{
3036 if (PyErr_Occurred()) {
3037 PyObject *type = 0;
3038 PyObject *value = 0;
3039 PyObject *traceback = 0;
3040 PyErr_Fetch(&type, &value, &traceback);
3041 if (value) {
3042 PyObject *old_str = PyObject_Str(value);
3043 PyObject *bytes = NULL;
3044 const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
3045 const char *errmesg = tmp ? tmp : "Invalid error message";
3046 SWIG_Py_XINCREF(type);
3047 PyErr_Clear();
3048 if (infront) {
3049 PyErr_Format(type, "%s %s", mesg, errmesg);
3050 } else {
3051 PyErr_Format(type, "%s %s", errmesg, mesg);
3052 }
3053 SWIG_Py_XDECREF(bytes);
3054 SWIG_Py_DECREF(old_str);
3055 }
3056 return 1;
3057 } else {
3058 return 0;
3059 }
3060}
3061
3062SWIGRUNTIME int
3064{
3065 if (PyErr_Occurred()) {
3066 /* add information about failing argument */
3067 char mesg[256];
3068 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
3069 return SWIG_Python_AddErrMesg(mesg, 1);
3070 } else {
3071 return 0;
3072 }
3073}
3074
3075SWIGRUNTIMEINLINE const char *
3077{
3078 SwigPyObject *v = (SwigPyObject *)self;
3079 swig_type_info *ty = v ? v->ty : 0;
3080 return ty ? ty->str : "";
3081}
3082
3083SWIGRUNTIME void
3084SWIG_Python_TypeError(const char *type, PyObject *obj)
3085{
3086 (void) obj;
3087 if (type) {
3088#if defined(SWIG_COBJECT_TYPES)
3089 if (obj && SwigPyObject_Check(obj)) {
3090 const char *otype = (const char *) SwigPyObject_GetDesc(obj);
3091 if (otype) {
3092 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
3093 type, otype);
3094 return;
3095 }
3096 } else
3097#endif
3098 {
3099#ifndef Py_LIMITED_API
3100 /* tp_name is not accessible */
3101 const char *otype = (obj ? obj->ob_type->tp_name : 0);
3102 if (otype) {
3103 PyObject *str = PyObject_Str(obj);
3104 PyObject *bytes = NULL;
3105 const char *cstr = str ? SWIG_PyUnicode_AsUTF8AndSize(str, NULL, &bytes) : 0;
3106 if (cstr) {
3107 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
3108 type, otype, cstr);
3109 } else {
3110 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
3111 type, otype);
3112 }
3113 SWIG_Py_XDECREF(bytes);
3114 SWIG_Py_XDECREF(str);
3115 return;
3116 }
3117#endif
3118 }
3119 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
3120 } else {
3121 PyErr_Format(PyExc_TypeError, "unexpected type is received");
3122 }
3123}
3124
3125
3126/* Convert a pointer value, signal an exception on a type mismatch */
3127SWIGRUNTIME void *
3128SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
3129 void *result;
3130 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
3131 PyErr_Clear();
3132 }
3133 return result;
3134}
3135
3136#ifdef SWIGPYTHON_BUILTIN
3137SWIGRUNTIME int
3138SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
3139 PyTypeObject *tp = obj->ob_type;
3140 PyObject *descr;
3141 PyObject *encoded_name;
3142 descrsetfunc f;
3143 int res = -1;
3144
3145# ifdef Py_USING_UNICODE
3146 if (PyString_Check(name)) {
3147 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
3148 if (!name)
3149 return -1;
3150 } else if (!PyUnicode_Check(name))
3151# else
3152 if (!PyString_Check(name))
3153# endif
3154 {
3155 PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
3156 return -1;
3157 } else {
3159 }
3160
3161 if (!tp->tp_dict) {
3162 if (PyType_Ready(tp) != 0)
3163 goto done;
3164 }
3165
3166 descr = _PyType_Lookup(tp, name);
3167 f = NULL;
3168 if (descr != NULL)
3169 f = descr->ob_type->tp_descr_set;
3170 if (!f) {
3171 if (PyString_Check(name)) {
3172 encoded_name = name;
3174 } else {
3175 encoded_name = PyUnicode_AsUTF8String(name);
3176 if (!encoded_name)
3177 goto done;
3178 }
3179 PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
3180 SWIG_Py_DECREF(encoded_name);
3181 } else {
3182 res = f(descr, obj, value);
3183 }
3184
3185 done:
3187 return res;
3188}
3189#endif
3190
3191
3192#ifdef __cplusplus
3193}
3194#endif
3195
3196
3197
3198#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3199
3200#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
3201
3202
3203
3204/* -------- TYPES TABLE (BEGIN) -------- */
3205
3206#define SWIGTYPE_p_PLGraphicsIn swig_types[0]
3207#define SWIGTYPE_p_PLcGrid swig_types[1]
3208#define SWIGTYPE_p_PLcGrid2 swig_types[2]
3209#define SWIGTYPE_p_char swig_types[3]
3210#define SWIGTYPE_p_double swig_types[4]
3211#define SWIGTYPE_p_f_double_double__int swig_types[5]
3212#define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[6]
3213#define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[7]
3214#define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[8]
3215#define SWIGTYPE_p_f_int_p_q_const__double_p_q_const__double__void swig_types[9]
3216#define SWIGTYPE_p_int swig_types[10]
3217#define SWIGTYPE_p_p_char swig_types[11]
3218#define SWIGTYPE_p_p_double swig_types[12]
3219#define SWIGTYPE_p_unsigned_int swig_types[13]
3221static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
3222#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3223#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3224
3225/* -------- TYPES TABLE (END) -------- */
3226
3227#ifdef SWIG_TypeQuery
3228# undef SWIG_TypeQuery
3229#endif
3230#define SWIG_TypeQuery SWIG_Python_TypeQuery
3231
3232/*-----------------------------------------------
3233 @(target):= _plplotc.so
3234 ------------------------------------------------*/
3235#if PY_VERSION_HEX >= 0x03000000
3236# define SWIG_init PyInit__plplotc
3237
3238#else
3239# define SWIG_init init_plplotc
3240
3241#endif
3242
3243#define SWIG_as_voidptr(a) (void *)((const void *)(a))
3244#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3245
3246
3247#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
3248#include <arrayobject.h>
3249#include "plplot.h"
3250#include "plplotP.h"
3251
3252#define NPY_PLINT NPY_INT32
3253
3254#ifdef PL_DOUBLE
3255#define NPY_PLFLT NPY_FLOAT64
3256#else
3257#define NPY_PLFLT NPY_FLOAT32
3258#endif
3259
3260// python-1.5 compatibility mode?
3261#if !defined ( PySequence_Fast_GET_ITEM )
3262 #define PySequence_Fast_GET_ITEM PySequence_GetItem
3263#endif
3264#define PySequence_Size PySequence_Length
3265
3266
3267 static PLINT Alen = 0;
3268 static PLINT Xlen = 0, Ylen = 0;
3269
3270
3271SWIGINTERN int
3272SWIG_AsVal_double (PyObject *obj, double *val)
3273{
3274 int res = SWIG_TypeError;
3275 if (PyFloat_Check(obj)) {
3276 if (val) *val = PyFloat_AsDouble(obj);
3277 return SWIG_OK;
3278#if PY_VERSION_HEX < 0x03000000
3279 } else if (PyInt_Check(obj)) {
3280 if (val) *val = (double) PyInt_AsLong(obj);
3281 return SWIG_OK;
3282#endif
3283 } else if (PyLong_Check(obj)) {
3284 double v = PyLong_AsDouble(obj);
3285 if (!PyErr_Occurred()) {
3286 if (val) *val = v;
3287 return SWIG_OK;
3288 } else {
3289 PyErr_Clear();
3290 }
3291 }
3292#ifdef SWIG_PYTHON_CAST_MODE
3293 {
3294 int dispatch = 0;
3295 double d = PyFloat_AsDouble(obj);
3296 if (!PyErr_Occurred()) {
3297 if (val) *val = d;
3298 return SWIG_AddCast(SWIG_OK);
3299 } else {
3300 PyErr_Clear();
3301 }
3302 if (!dispatch) {
3303 long v = PyLong_AsLong(obj);
3304 if (!PyErr_Occurred()) {
3305 if (val) *val = v;
3307 } else {
3308 PyErr_Clear();
3309 }
3310 }
3311 }
3312#endif
3313 return res;
3314}
3315
3316
3317 #define SWIG_From_double PyFloat_FromDouble
3318
3319
3320 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
3321 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
3322 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3323 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
3324 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
3326 typedef void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer );
3327
3328
3329SWIGINTERNINLINE PyObject*
3331{
3332 return PyInt_FromLong((long) value);
3333}
3334
3335
3336#include <limits.h>
3337#if !defined(SWIG_NO_LLONG_MAX)
3338# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3339# define LLONG_MAX __LONG_LONG_MAX__
3340# define LLONG_MIN (-LLONG_MAX - 1LL)
3341# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3342# endif
3343#endif
3344
3345
3346#include <errno.h>
3347
3348
3349#include <float.h>
3350
3351
3352#include <math.h>
3353
3354
3356SWIG_CanCastAsInteger(double *d, double min, double max) {
3357 double x = *d;
3358 if ((min <= x && x <= max)) {
3359 double fx, cx, rd;
3360 errno = 0;
3361 fx = floor(x);
3362 cx = ceil(x);
3363 rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3364 if ((errno == EDOM) || (errno == ERANGE)) {
3365 errno = 0;
3366 } else {
3367 double summ, reps, diff;
3368 if (rd < x) {
3369 diff = x - rd;
3370 } else if (rd > x) {
3371 diff = rd - x;
3372 } else {
3373 return 1;
3374 }
3375 summ = rd + x;
3376 reps = diff/summ;
3377 if (reps < 8*DBL_EPSILON) {
3378 *d = rd;
3379 return 1;
3380 }
3381 }
3382 }
3383 return 0;
3384}
3385
3386
3387SWIGINTERN int
3388SWIG_AsVal_long (PyObject *obj, long* val)
3389{
3390#if PY_VERSION_HEX < 0x03000000
3391 if (PyInt_Check(obj)) {
3392 if (val) *val = PyInt_AsLong(obj);
3393 return SWIG_OK;
3394 } else
3395#endif
3396 if (PyLong_Check(obj)) {
3397 long v = PyLong_AsLong(obj);
3398 if (!PyErr_Occurred()) {
3399 if (val) *val = v;
3400 return SWIG_OK;
3401 } else {
3402 PyErr_Clear();
3403 return SWIG_OverflowError;
3404 }
3405 }
3406#ifdef SWIG_PYTHON_CAST_MODE
3407 {
3408 int dispatch = 0;
3409 long v = PyInt_AsLong(obj);
3410 if (!PyErr_Occurred()) {
3411 if (val) *val = v;
3412 return SWIG_AddCast(SWIG_OK);
3413 } else {
3414 PyErr_Clear();
3415 }
3416 if (!dispatch) {
3417 double d;
3418 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3419 // Largest double not larger than LONG_MAX (not portably calculated easily)
3420 // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
3421 // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
3422 const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
3423 // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
3424 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
3425 if (val) *val = (long)(d);
3426 return res;
3427 }
3428 }
3429 }
3430#endif
3431 return SWIG_TypeError;
3432}
3433
3434
3435SWIGINTERN int
3436SWIG_AsVal_int (PyObject * obj, int *val)
3437{
3438 long v;
3439 int res = SWIG_AsVal_long (obj, &v);
3440 if (SWIG_IsOK(res)) {
3441 if ((v < INT_MIN || v > INT_MAX)) {
3442 return SWIG_OverflowError;
3443 } else {
3444 if (val) *val = (int)(v);
3445 }
3446 }
3447 return res;
3448}
3449
3450
3451SWIGINTERN int
3452SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3453{
3454#if PY_VERSION_HEX < 0x03000000
3455 if (PyInt_Check(obj)) {
3456 long v = PyInt_AsLong(obj);
3457 if (v >= 0) {
3458 if (val) *val = v;
3459 return SWIG_OK;
3460 } else {
3461 return SWIG_OverflowError;
3462 }
3463 } else
3464#endif
3465 if (PyLong_Check(obj)) {
3466 unsigned long v = PyLong_AsUnsignedLong(obj);
3467 if (!PyErr_Occurred()) {
3468 if (val) *val = v;
3469 return SWIG_OK;
3470 } else {
3471 PyErr_Clear();
3472 return SWIG_OverflowError;
3473 }
3474 }
3475#ifdef SWIG_PYTHON_CAST_MODE
3476 {
3477 int dispatch = 0;
3478 unsigned long v = PyLong_AsUnsignedLong(obj);
3479 if (!PyErr_Occurred()) {
3480 if (val) *val = v;
3481 return SWIG_AddCast(SWIG_OK);
3482 } else {
3483 PyErr_Clear();
3484 }
3485 if (!dispatch) {
3486 double d;
3487 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3488 // Largest double not larger than ULONG_MAX (not portably calculated easily)
3489 // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
3490 // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
3491 const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
3492 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
3493 if (val) *val = (unsigned long)(d);
3494 return res;
3495 }
3496 }
3497 }
3498#endif
3499 return SWIG_TypeError;
3500}
3501
3502
3503SWIGINTERN int
3504SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3505{
3506 unsigned long v;
3507 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3508 if (SWIG_IsOK(res)) {
3509 if ((v > UINT_MAX)) {
3510 return SWIG_OverflowError;
3511 } else {
3512 if (val) *val = (unsigned int)(v);
3513 }
3514 }
3515 return res;
3516}
3517
3518
3519SWIGINTERNINLINE PyObject*
3521{
3522 return PyInt_FromSize_t((size_t) value);
3523}
3524
3525
3528{
3529 static swig_type_info* info = 0;
3530 if (!info) {
3531 info = SWIG_TypeQuery("_p_char");
3532 }
3533 return info;
3534}
3535
3536
3537/* Return string from Python obj. NOTE: obj must remain in scope in order
3538 to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
3539SWIGINTERN int
3540SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
3541{
3542#if PY_VERSION_HEX>=0x03000000
3543#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3544 if (PyBytes_Check(obj))
3545#else
3546 if (PyUnicode_Check(obj))
3547#endif
3548#else
3549 if (PyString_Check(obj))
3550#endif
3551 {
3552 char *cstr; Py_ssize_t len;
3553 PyObject *bytes = NULL;
3554 int ret = SWIG_OK;
3555 if (alloc)
3556 *alloc = SWIG_OLDOBJ;
3557#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3558 if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
3559 return SWIG_TypeError;
3560#else
3561 cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
3562 if (!cstr)
3563 return SWIG_TypeError;
3564 /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
3565 if (bytes && cptr) {
3566 if (alloc) {
3567 cstr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3568 *alloc = SWIG_NEWOBJ;
3569 } else {
3570 /* alloc must be set in order to clean up allocated memory */
3571 return SWIG_RuntimeError;
3572 }
3573 }
3574#endif
3575 if (cptr) *cptr = cstr;
3576 if (psize) *psize = len + 1;
3577 SWIG_Py_XDECREF(bytes);
3578 return ret;
3579 } else {
3580#if defined(SWIG_PYTHON_2_UNICODE)
3581#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3582#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3583#endif
3584#if PY_VERSION_HEX<0x03000000
3585 if (PyUnicode_Check(obj)) {
3586 char *cstr; Py_ssize_t len;
3587 if (!alloc && cptr) {
3588 return SWIG_RuntimeError;
3589 }
3590 obj = PyUnicode_AsUTF8String(obj);
3591 if (!obj)
3592 return SWIG_TypeError;
3593 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3594 if (cptr) {
3595 if (alloc) *alloc = SWIG_NEWOBJ;
3596 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3597 }
3598 if (psize) *psize = len + 1;
3599
3600 SWIG_Py_XDECREF(obj);
3601 return SWIG_OK;
3602 } else {
3603 SWIG_Py_XDECREF(obj);
3604 }
3605 }
3606#endif
3607#endif
3608
3609 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3610 if (pchar_descriptor) {
3611 void* vptr = 0;
3612 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3613 if (cptr) *cptr = (char *) vptr;
3614 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3615 if (alloc) *alloc = SWIG_OLDOBJ;
3616 return SWIG_OK;
3617 }
3618 }
3619 }
3620 return SWIG_TypeError;
3621}
3622
3623
3624SWIGINTERN int
3625SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3626{
3627 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3628 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3629 if (SWIG_IsOK(res)) {
3630 /* special case of single char conversion when we don't need space for NUL */
3631 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3632 if (csize <= size) {
3633 if (val) {
3634 if (csize) memcpy(val, cptr, csize*sizeof(char));
3635 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3636 }
3637 if (alloc == SWIG_NEWOBJ) {
3638 free((char*)cptr);
3639 res = SWIG_DelNewMask(res);
3640 }
3641 return res;
3642 }
3643 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3644 }
3645 return SWIG_TypeError;
3646}
3647
3648
3649SWIGINTERNINLINE PyObject *
3650SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3651{
3652 if (carray) {
3653 if (size > INT_MAX) {
3654 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3655 return pchar_descriptor ?
3656 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3657 } else {
3658#if PY_VERSION_HEX >= 0x03000000
3659#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3660 return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3661#else
3662 return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3663#endif
3664#else
3665 return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3666#endif
3667 }
3668 } else {
3669 return SWIG_Py_Void();
3670 }
3671}
3672
3673
3674SWIGINTERN size_t
3675SWIG_strnlen(const char* s, size_t maxlen)
3676{
3677 const char *p;
3678 for (p = s; maxlen-- && *p; p++)
3679 ;
3680 return p - s;
3681}
3682
3683
3684
3685
3686
3687SWIGINTERN int
3688SWIG_AsVal_char (PyObject * obj, char *val)
3689{
3690 int res = SWIG_AsCharArray(obj, val, 1);
3691 if (!SWIG_IsOK(res)) {
3692 long v;
3693 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3694 if (SWIG_IsOK(res)) {
3695 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3696 if (val) *val = (char)(v);
3697 } else {
3698 res = SWIG_OverflowError;
3699 }
3700 }
3701 }
3702 return res;
3703}
3704
3705#ifdef __cplusplus
3706extern "C" {
3707#endif
3708
3709 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3710
3711// some really twisted stuff to allow calling a single precision library from python
3712 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3713 {
3714 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3715 mindims, maxdims );
3716 if ( !tmp )
3717 {
3718 // could be an incoming long array which can't be "safely" converted, do it anyway
3719 if ( PyArray_Check( in ) )
3720 {
3721 PyErr_Clear();
3722 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3723 }
3724 }
3725 return tmp;
3726 }
3727
3728
3729#define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3730
3731SWIGINTERN PyObject *_wrap_pltr0(PyObject *self, PyObject *args) {
3732 PyObject *resultobj = 0;
3733 PLFLT arg1 ;
3734 PLFLT arg2 ;
3735 PLFLT *arg3 = 0 ;
3736 PLFLT *arg4 = 0 ;
3737 PLPointer arg5 = 0 ;
3738 double val1 ;
3739 int ecode1 = 0 ;
3740 double val2 ;
3741 int ecode2 = 0 ;
3742 PLFLT temp3 ;
3743 int res3 = SWIG_TMPOBJ ;
3744 PLFLT temp4 ;
3745 int res4 = SWIG_TMPOBJ ;
3746 PyObject *swig_obj[2] ;
3747
3748 arg3 = &temp3;
3749 arg4 = &temp4;
3750 {
3751 arg5 = NULL;
3752 }
3753 (void)self;
3754 if (!SWIG_Python_UnpackTuple(args, "pltr0", 2, 2, swig_obj)) SWIG_fail;
3755 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3756 if (!SWIG_IsOK(ecode1)) {
3757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3758 }
3759 arg1 = (PLFLT)(val1);
3760 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3761 if (!SWIG_IsOK(ecode2)) {
3762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3763 }
3764 arg2 = (PLFLT)(val2);
3765 pltr0(arg1,arg2,arg3,arg4,arg5);
3766 resultobj = SWIG_Py_Void();
3767 if (SWIG_IsTmpObj(res3)) {
3768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
3769 } else {
3770 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3771 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
3772 }
3773 if (SWIG_IsTmpObj(res4)) {
3774 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
3775 } else {
3776 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3777 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
3778 }
3779 return resultobj;
3780fail:
3781 return NULL;
3782}
3783
3784
3785
3786 PyArrayObject *pltr_xg, *pltr_yg;
3789
3790 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3791 void cleanup_PLcGrid1( void );
3792 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3793 void cleanup_PLcGrid2( void );
3794
3795 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3796 {
3797 // fprintf(stderr, "marshal PLcGrid1\n");
3798 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3799 {
3800 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3801 return NULL;
3802 }
3803 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3804 NPY_PLFLT, 1, 1 );
3805 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3806 NPY_PLFLT, 1, 1 );
3807 if ( pltr_xg == 0 || pltr_yg == 0 )
3808 {
3809 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3810 return NULL;
3811 }
3812 tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3813 tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3814 if ( isimg == 0 )
3815 {
3816 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3817 {
3818 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3819 return NULL;
3820 }
3821 }
3822 else
3823 {
3824 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3825 {
3826 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3827 return NULL;
3828 }
3829 }
3830 tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3831 tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3832 return &tmpGrid1;
3833 }
3834
3835 void cleanup_PLcGrid1( void )
3836 {
3837 // fprintf(stderr, "cleanup PLcGrid1\n");
3838 Py_CLEAR( pltr_xg );
3839 Py_CLEAR( pltr_yg );
3840 }
3841
3842 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3843 {
3844 int i, size;
3845 // fprintf(stderr, "marshal PLcGrid2\n");
3846 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3847 {
3848 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3849 return NULL;
3850 }
3851 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3852 NPY_PLFLT, 2, 2 );
3853 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3854 NPY_PLFLT, 2, 2 );
3855 if ( pltr_xg == 0 || pltr_yg == 0 )
3856 {
3857 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3858 return NULL;
3859 }
3860 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3861 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3862 {
3863 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3864 return NULL;
3865 }
3866 tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3867 tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3868 if ( isimg == 0 )
3869 {
3870 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3871 {
3872 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3873 return NULL;
3874 }
3875 }
3876 else
3877 {
3878 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3879 {
3880 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3881 return NULL;
3882 }
3883 }
3884 size = tmpGrid2.ny;
3885 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3886 for ( i = 0; i < tmpGrid2.nx; i++ )
3887 tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3888 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3889 for ( i = 0; i < tmpGrid2.nx; i++ )
3890 tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3891 return &tmpGrid2;
3892 }
3893
3894 void cleanup_PLcGrid2( void )
3895 {
3896 // fprintf(stderr, "cleanup PLcGrid2\n");
3897 free( tmpGrid2.xg );
3898 free( tmpGrid2.yg );
3899 Py_CLEAR( pltr_xg );
3900 Py_CLEAR( pltr_yg );
3901 }
3902
3903SWIGINTERN PyObject *_wrap_pltr1(PyObject *self, PyObject *args) {
3904 PyObject *resultobj = 0;
3905 PLFLT arg1 ;
3906 PLFLT arg2 ;
3907 PLFLT *arg3 = 0 ;
3908 PLFLT *arg4 = 0 ;
3909 PLcGrid *arg5 = 0 ;
3910 double val1 ;
3911 int ecode1 = 0 ;
3912 double val2 ;
3913 int ecode2 = 0 ;
3914 PLFLT temp3 ;
3915 int res3 = SWIG_TMPOBJ ;
3916 PLFLT temp4 ;
3917 int res4 = SWIG_TMPOBJ ;
3918 PyObject *swig_obj[3] ;
3919
3920 arg3 = &temp3;
3921 arg4 = &temp4;
3922 (void)self;
3923 if (!SWIG_Python_UnpackTuple(args, "pltr1", 3, 3, swig_obj)) SWIG_fail;
3924 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3925 if (!SWIG_IsOK(ecode1)) {
3926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3927 }
3928 arg1 = (PLFLT)(val1);
3929 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3930 if (!SWIG_IsOK(ecode2)) {
3931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3932 }
3933 arg2 = (PLFLT)(val2);
3934 {
3935 arg5 = marshal_PLcGrid1( swig_obj[2], 0 );
3936 if ( !arg5 )
3937 return NULL;
3938 }
3939 pltr1(arg1,arg2,arg3,arg4,arg5);
3940 resultobj = SWIG_Py_Void();
3941 if (SWIG_IsTmpObj(res3)) {
3942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
3943 } else {
3944 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
3946 }
3947 if (SWIG_IsTmpObj(res4)) {
3948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
3949 } else {
3950 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
3952 }
3953 {
3955 }
3956 return resultobj;
3957fail:
3958 {
3960 }
3961 return NULL;
3962}
3963
3964
3965SWIGINTERN PyObject *_wrap_pltr2(PyObject *self, PyObject *args) {
3966 PyObject *resultobj = 0;
3967 PLFLT arg1 ;
3968 PLFLT arg2 ;
3969 PLFLT *arg3 = 0 ;
3970 PLFLT *arg4 = 0 ;
3971 PLcGrid2 *arg5 = 0 ;
3972 double val1 ;
3973 int ecode1 = 0 ;
3974 double val2 ;
3975 int ecode2 = 0 ;
3976 PLFLT temp3 ;
3977 int res3 = SWIG_TMPOBJ ;
3978 PLFLT temp4 ;
3979 int res4 = SWIG_TMPOBJ ;
3980 PyObject *swig_obj[3] ;
3981
3982 arg3 = &temp3;
3983 arg4 = &temp4;
3984 (void)self;
3985 if (!SWIG_Python_UnpackTuple(args, "pltr2", 3, 3, swig_obj)) SWIG_fail;
3986 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3987 if (!SWIG_IsOK(ecode1)) {
3988 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3989 }
3990 arg1 = (PLFLT)(val1);
3991 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3992 if (!SWIG_IsOK(ecode2)) {
3993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3994 }
3995 arg2 = (PLFLT)(val2);
3996 {
3997 arg5 = marshal_PLcGrid2( swig_obj[2], 0 );
3998 if ( !arg5 )
3999 return NULL;
4000 }
4001 pltr2(arg1,arg2,arg3,arg4,arg5);
4002 resultobj = SWIG_Py_Void();
4003 if (SWIG_IsTmpObj(res3)) {
4004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
4005 } else {
4006 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
4008 }
4009 if (SWIG_IsTmpObj(res4)) {
4010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
4011 } else {
4012 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
4014 }
4015 {
4017 }
4018 return resultobj;
4019fail:
4020 {
4022 }
4023 return NULL;
4024}
4025
4026
4027
4028 // helper code for handling the callback
4029#if 0
4030 static PyInterpreterState *save_interp = NULL;
4031#endif
4033 PyObject* python_pltr = NULL;
4034 PyObject* python_f2eval = NULL;
4035 PyObject* python_ct = NULL;
4036 PyObject* python_mapform = NULL;
4037 PyObject* python_label = NULL;
4038
4039#if 0
4040#define MY_BLOCK_THREADS { \
4041 PyThreadState *prev_state, *new_state; \
4042 /* need to have started a thread at some stage */ \
4043 /* for the following to work */ \
4044 PyEval_AcquireLock(); \
4045 new_state = PyThreadState_New( save_interp ); \
4046 prev_state = PyThreadState_Swap( new_state );
4047#define MY_UNBLOCK_THREADS \
4048 new_state = PyThreadState_Swap( prev_state ); \
4049 PyThreadState_Clear( new_state ); \
4050 PyEval_ReleaseLock(); \
4051 PyThreadState_Delete( new_state ); \
4052 }
4053#else
4054#define MY_BLOCK_THREADS
4055#define MY_UNBLOCK_THREADS
4056#endif
4057
4058// Function prototypes
4059 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
4061 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
4062 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
4063 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
4064 pltr_func marshal_pltr( PyObject* input );
4065 void cleanup_pltr( void );
4066 ct_func marshal_ct( PyObject* input );
4067 void cleanup_ct( void );
4068 mapform_func marshal_mapform( PyObject* input );
4069 void cleanup_mapform( void );
4070 PLPointer marshal_PLPointer( PyObject* input, int isimg );
4071 void cleanup_PLPointer( void );
4072
4073
4074// This is the callback that gets handed to the C code. It, in turn, calls the Python callback
4075
4076 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
4077 {
4078 PyObject *pdata, *arglist, *result;
4079 PyArrayObject *tmp;
4080
4081 // the data argument is acutally a pointer to a python object
4082 pdata = (PyObject *) data;
4083 if ( data == NULL )
4084 {
4085 pdata = Py_None;
4086 }
4087 if ( python_pltr ) // if not something is terribly wrong
4088 { // hold a reference to the data object
4089 Py_XINCREF( pdata );
4090 // grab the Global Interpreter Lock to be sure threads don't mess us up
4092 // build the argument list
4093#ifdef PL_DOUBLE
4094 arglist = Py_BuildValue( "(ddO)", x, y, pdata );
4095#else
4096 arglist = Py_BuildValue( "(ffO)", x, y, pdata );
4097#endif
4098 if ( arglist == NULL )
4099 {
4100 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
4101 *tx = *ty = 0;
4102 return;
4103 }
4104 // call the python function
4105 result = PyObject_CallObject( python_pltr, arglist );
4106 // release the argument list
4107 Py_CLEAR( arglist );
4108 // check and unpack the result
4109 if ( result == NULL )
4110 {
4111 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
4112 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
4113 *tx = *ty = 0;
4114 }
4115 else
4116 {
4117 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
4118 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
4119 {
4120 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
4121 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
4122 *tx = *ty = 0;
4123 }
4124 else
4125 {
4126 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
4127 *tx = t[0];
4128 *ty = t[1];
4129 Py_CLEAR( tmp );
4130 }
4131 }
4132 // release the result
4133 Py_CLEAR( result );
4134 // release the global interpreter lock
4136 }
4137 }
4138
4140 {
4141 PyObject *pdata, *arglist, *result;
4142 PLFLT fresult = 0.0;
4143
4144 // the data argument is acutally a pointer to a python object
4145 pdata = (PyObject *) data;
4146 if ( python_f2eval ) // if not something is terribly wrong
4147 { // hold a reference to the data object
4148 Py_XINCREF( pdata );
4149 // grab the Global Interpreter Lock to be sure threads don't mess us up
4151 // build the argument list
4152 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
4153 // call the python function
4154 result = PyObject_CallObject( python_f2eval, arglist );
4155 // release the argument list
4156 Py_CLEAR( arglist );
4157 // check and unpack the result
4158 if ( !PyFloat_Check( result ) )
4159 {
4160 fprintf( stderr, "f2eval callback must return a float\n" );
4161 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
4162 }
4163 else
4164 {
4165 // should I test the type here?
4166 fresult = (PLFLT) PyFloat_AsDouble( result );
4167 }
4168 // release the result
4169 Py_CLEAR( result );
4170 // release the global interpreter lock
4172 }
4173 return fresult;
4174 }
4175
4176 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
4177 {
4178 PyObject *pdata, *arglist, *result, *unicode_string;
4179 char *pystring;
4180
4181 // the data argument is acutally a pointer to a python object
4182 if ( data )
4183 pdata = (PyObject *) data;
4184 else
4185 pdata = Py_None;
4186 if ( python_label ) // if not something is terribly wrong
4187 { // hold a reference to the data object
4188 Py_XINCREF( pdata );
4189 // grab the Global Interpreter Lock to be sure threads don't mess us up
4191 // build the argument list
4192#ifdef PL_DOUBLE
4193 arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
4194#else
4195 arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
4196#endif
4197 // call the python function
4198 result = PyObject_CallObject( python_label, arglist );
4199 // release the argument list
4200 //Py_CLEAR(arglist);
4201 // check and unpack the result
4202 if ( result == NULL )
4203 {
4204 fprintf( stderr, "label callback failed with 3 arguments\n" );
4205 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
4206 }
4207 else if ( PyString_Check( result ) )
4208 {
4209 // should I test the type here?
4210 pystring = PyString_AsString( result );
4211 strncpy( string, pystring, len );
4212 }
4213 else if ( PyUnicode_Check( result ) )
4214 {
4215 // unicode_string is never freed? memory leak here?
4216 unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
4217 pystring = PyBytes_AS_STRING( unicode_string );
4218 // len may be different then the byte string length w/ unicode?
4219 strncpy( string, pystring, len );
4220 }
4221 else
4222 {
4223 fprintf( stderr, "label callback must return a string\n" );
4224 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
4225 }
4226 // release the result
4227 Py_CLEAR( result );
4228 // release the global interpreter lock
4230 }
4231 }
4232
4233 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
4234 {
4235 PyObject *px, *py, *pdata, *arglist, *result;
4236 npy_intp n;
4237 n = 1;
4238
4239 // the data argument is acutally a pointer to a python object
4240 pdata = (PyObject *) data;
4241 if ( data == NULL )
4242 {
4243 pdata = Py_None;
4244 }
4245 if ( python_ct ) // if not something is terribly wrong
4246 { // hold a reference to the data object
4247 Py_XINCREF( pdata );
4248 // grab the Global Interpreter Lock to be sure threads don't mess us up
4250 // build the argument list
4251 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
4252 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
4253 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
4254 // call the python function
4255 result = PyObject_CallObject( python_ct, arglist );
4256 // release the argument list
4257 Py_CLEAR( arglist );
4258 Py_CLEAR( px );
4259 Py_CLEAR( py );
4260 Py_CLEAR( pdata );
4261 // check and unpack the result
4262 if ( result == NULL )
4263 {
4264 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
4265 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
4266 }
4267 // release the result
4268 Py_CLEAR( result );
4269 // release the global interpreter lock
4271 }
4272 }
4273
4275 {
4276 PyObject *px, *py, *arglist, *result;
4277 // PyArrayObject *tmpx, *tmpy;
4278// PLFLT *xx, *yy;
4279// PLINT i;
4280 npy_intp nn;
4281 nn = n;
4282
4283 if ( python_mapform ) // if not something is terribly wrong
4284 { // grab the Global Interpreter Lock to be sure threads don't mess us up
4286 // build the argument list
4287#ifdef PL_HAVE_PTHREAD
4288 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
4289 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
4290#else
4291 px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
4292 py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
4293#endif
4294 arglist = Py_BuildValue( "(iOO)", n, px, py );
4295 // call the python function
4296 result = PyObject_CallObject( python_mapform, arglist );
4297 // release the argument list
4298 Py_CLEAR( arglist );
4299 Py_CLEAR( px );
4300 Py_CLEAR( py );
4301 // check and unpack the result
4302 if ( result == NULL )
4303 {
4304 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
4305 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
4306 }
4307 // release the result
4308 Py_CLEAR( result );
4309 // release the global interpreter lock
4311 }
4312 }
4313
4314// marshal the pltr function pointer argument
4315 pltr_func marshal_pltr( PyObject* input )
4316 {
4317 pltr_func result = do_pltr_callback;
4318 PyObject * rep = PyObject_Repr( input );
4319 if ( rep )
4320 {
4321 // Memory leaks here? str and uni_str are not freed?
4322 char* str;
4323 if ( PyUnicode_Check( rep ) )
4324 {
4325 PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
4326 str = PyBytes_AS_STRING( uni_str );
4327 }
4328 else
4329 {
4330 str = PyString_AsString( rep );
4331 }
4332 if ( strstr( str, "function pltr0" ) != 0 )
4333 {
4334 result = pltr0;
4335 pltr_type = CB_0;
4336 python_pltr = NULL;
4337 }
4338 else if ( strstr( str, "function pltr1" ) != 0 )
4339 {
4340 result = pltr1;
4341 pltr_type = CB_1;
4342 python_pltr = NULL;
4343 }
4344 else if ( strstr( str, "function pltr2" ) != 0 )
4345 {
4346 result = pltr2;
4347 pltr_type = CB_2;
4348 python_pltr = NULL;
4349 }
4350 else
4351 {
4352 python_pltr = input;
4354 Py_XINCREF( input );
4355 }
4356 Py_CLEAR( rep );
4357 }
4358 else
4359 {
4360 python_pltr = input;
4362 Py_XINCREF( input );
4363 }
4364 return result;
4365 }
4366
4367 void cleanup_pltr( void )
4368 {
4369 Py_CLEAR( python_pltr );
4370 python_pltr = 0;
4371 }
4372
4373// marshal the ct function pointer argument
4374 ct_func marshal_ct( PyObject* input )
4375 {
4376 ct_func result = do_ct_callback;
4377 python_ct = input;
4378 Py_XINCREF( input );
4379 return result;
4380 }
4381
4382 void cleanup_ct( void )
4383 {
4384 Py_CLEAR( python_ct );
4385 python_ct = 0;
4386 }
4387
4388// marshal the mapform function pointer argument
4390 {
4392 python_mapform = input;
4393 Py_XINCREF( input );
4394 return result;
4395 }
4396
4397 void cleanup_mapform( void )
4398 {
4399 Py_CLEAR( python_mapform );
4400 python_mapform = 0;
4401 }
4402
4403 PLPointer marshal_PLPointer( PyObject* input, int isimg )
4404 {
4405 PLPointer result = NULL;
4406 switch ( pltr_type )
4407 {
4408 case CB_0:
4409 break;
4410 case CB_1:
4411 if ( input != Py_None )
4412 result = marshal_PLcGrid1( input, isimg );
4413 break;
4414 case CB_2:
4415 if ( input != Py_None )
4416 result = marshal_PLcGrid2( input, isimg );
4417 break;
4418 case CB_Python:
4419 Py_XINCREF( input );
4420 result = (PLPointer *) input;
4421 break;
4422 default:
4423 fprintf( stderr, "pltr_type is invalid\n" );
4424 }
4425 return result;
4426 }
4427
4429 {
4430 switch ( pltr_type )
4431 {
4432 case CB_0:
4433 break;
4434 case CB_1:
4436 break;
4437 case CB_2:
4439 break;
4440 case CB_Python:
4441 Py_CLEAR( python_pltr );
4442 break;
4443 default:
4444 fprintf( stderr, "pltr_type is invalid\n" );
4445 }
4446 python_pltr = 0;
4447 pltr_type = CB_0;
4448 }
4449
4450
4451
4452SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args) {
4453 PyObject *resultobj = 0;
4454 PLGraphicsIn *arg1 = 0 ;
4455 int arg2 ;
4456 void *argp1 = 0 ;
4457 int res1 = 0 ;
4458 int val2 ;
4459 int ecode2 = 0 ;
4460 PyObject *swig_obj[2] ;
4461
4462 (void)self;
4463 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_type_set", 2, 2, swig_obj)) SWIG_fail;
4464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4465 if (!SWIG_IsOK(res1)) {
4466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4467 }
4468 arg1 = (PLGraphicsIn *)(argp1);
4469 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4470 if (!SWIG_IsOK(ecode2)) {
4471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4472 }
4473 arg2 = (int)(val2);
4474 if (arg1) (arg1)->type = arg2;
4475 resultobj = SWIG_Py_Void();
4476 return resultobj;
4477fail:
4478 return NULL;
4479}
4480
4481
4482SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args) {
4483 PyObject *resultobj = 0;
4484 PLGraphicsIn *arg1 = 0 ;
4485 void *argp1 = 0 ;
4486 int res1 = 0 ;
4487 PyObject *swig_obj[1] ;
4488 int result;
4489
4490 (void)self;
4491 if (!args) SWIG_fail;
4492 swig_obj[0] = args;
4493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4494 if (!SWIG_IsOK(res1)) {
4495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4496 }
4497 arg1 = (PLGraphicsIn *)(argp1);
4498 result = (int) ((arg1)->type);
4499 resultobj = SWIG_From_int((int)(result));
4500 return resultobj;
4501fail:
4502 return NULL;
4503}
4504
4505
4506SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args) {
4507 PyObject *resultobj = 0;
4508 PLGraphicsIn *arg1 = 0 ;
4509 unsigned int arg2 ;
4510 void *argp1 = 0 ;
4511 int res1 = 0 ;
4512 unsigned int val2 ;
4513 int ecode2 = 0 ;
4514 PyObject *swig_obj[2] ;
4515
4516 (void)self;
4517 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_state_set", 2, 2, swig_obj)) SWIG_fail;
4518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4519 if (!SWIG_IsOK(res1)) {
4520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4521 }
4522 arg1 = (PLGraphicsIn *)(argp1);
4523 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4524 if (!SWIG_IsOK(ecode2)) {
4525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4526 }
4527 arg2 = (unsigned int)(val2);
4528 if (arg1) (arg1)->state = arg2;
4529 resultobj = SWIG_Py_Void();
4530 return resultobj;
4531fail:
4532 return NULL;
4533}
4534
4535
4536SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args) {
4537 PyObject *resultobj = 0;
4538 PLGraphicsIn *arg1 = 0 ;
4539 void *argp1 = 0 ;
4540 int res1 = 0 ;
4541 PyObject *swig_obj[1] ;
4542 unsigned int result;
4543
4544 (void)self;
4545 if (!args) SWIG_fail;
4546 swig_obj[0] = args;
4547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4548 if (!SWIG_IsOK(res1)) {
4549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4550 }
4551 arg1 = (PLGraphicsIn *)(argp1);
4552 result = (unsigned int) ((arg1)->state);
4553 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4554 return resultobj;
4555fail:
4556 return NULL;
4557}
4558
4559
4560SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args) {
4561 PyObject *resultobj = 0;
4562 PLGraphicsIn *arg1 = 0 ;
4563 unsigned int arg2 ;
4564 void *argp1 = 0 ;
4565 int res1 = 0 ;
4566 unsigned int val2 ;
4567 int ecode2 = 0 ;
4568 PyObject *swig_obj[2] ;
4569
4570 (void)self;
4571 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_keysym_set", 2, 2, swig_obj)) SWIG_fail;
4572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4573 if (!SWIG_IsOK(res1)) {
4574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4575 }
4576 arg1 = (PLGraphicsIn *)(argp1);
4577 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4578 if (!SWIG_IsOK(ecode2)) {
4579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4580 }
4581 arg2 = (unsigned int)(val2);
4582 if (arg1) (arg1)->keysym = arg2;
4583 resultobj = SWIG_Py_Void();
4584 return resultobj;
4585fail:
4586 return NULL;
4587}
4588
4589
4590SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args) {
4591 PyObject *resultobj = 0;
4592 PLGraphicsIn *arg1 = 0 ;
4593 void *argp1 = 0 ;
4594 int res1 = 0 ;
4595 PyObject *swig_obj[1] ;
4596 unsigned int result;
4597
4598 (void)self;
4599 if (!args) SWIG_fail;
4600 swig_obj[0] = args;
4601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4602 if (!SWIG_IsOK(res1)) {
4603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4604 }
4605 arg1 = (PLGraphicsIn *)(argp1);
4606 result = (unsigned int) ((arg1)->keysym);
4607 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4608 return resultobj;
4609fail:
4610 return NULL;
4611}
4612
4613
4614SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args) {
4615 PyObject *resultobj = 0;
4616 PLGraphicsIn *arg1 = 0 ;
4617 unsigned int arg2 ;
4618 void *argp1 = 0 ;
4619 int res1 = 0 ;
4620 unsigned int val2 ;
4621 int ecode2 = 0 ;
4622 PyObject *swig_obj[2] ;
4623
4624 (void)self;
4625 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_button_set", 2, 2, swig_obj)) SWIG_fail;
4626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4627 if (!SWIG_IsOK(res1)) {
4628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4629 }
4630 arg1 = (PLGraphicsIn *)(argp1);
4631 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4632 if (!SWIG_IsOK(ecode2)) {
4633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4634 }
4635 arg2 = (unsigned int)(val2);
4636 if (arg1) (arg1)->button = arg2;
4637 resultobj = SWIG_Py_Void();
4638 return resultobj;
4639fail:
4640 return NULL;
4641}
4642
4643
4644SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args) {
4645 PyObject *resultobj = 0;
4646 PLGraphicsIn *arg1 = 0 ;
4647 void *argp1 = 0 ;
4648 int res1 = 0 ;
4649 PyObject *swig_obj[1] ;
4650 unsigned int result;
4651
4652 (void)self;
4653 if (!args) SWIG_fail;
4654 swig_obj[0] = args;
4655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4656 if (!SWIG_IsOK(res1)) {
4657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4658 }
4659 arg1 = (PLGraphicsIn *)(argp1);
4660 result = (unsigned int) ((arg1)->button);
4661 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4662 return resultobj;
4663fail:
4664 return NULL;
4665}
4666
4667
4668SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args) {
4669 PyObject *resultobj = 0;
4670 PLGraphicsIn *arg1 = 0 ;
4671 PLINT arg2 ;
4672 void *argp1 = 0 ;
4673 int res1 = 0 ;
4674 int val2 ;
4675 int ecode2 = 0 ;
4676 PyObject *swig_obj[2] ;
4677
4678 (void)self;
4679 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_subwindow_set", 2, 2, swig_obj)) SWIG_fail;
4680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4681 if (!SWIG_IsOK(res1)) {
4682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4683 }
4684 arg1 = (PLGraphicsIn *)(argp1);
4685 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4686 if (!SWIG_IsOK(ecode2)) {
4687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4688 }
4689 arg2 = (PLINT)(val2);
4690 if (arg1) (arg1)->subwindow = arg2;
4691 resultobj = SWIG_Py_Void();
4692 return resultobj;
4693fail:
4694 return NULL;
4695}
4696
4697
4698SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args) {
4699 PyObject *resultobj = 0;
4700 PLGraphicsIn *arg1 = 0 ;
4701 void *argp1 = 0 ;
4702 int res1 = 0 ;
4703 PyObject *swig_obj[1] ;
4704 PLINT result;
4705
4706 (void)self;
4707 if (!args) SWIG_fail;
4708 swig_obj[0] = args;
4709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4710 if (!SWIG_IsOK(res1)) {
4711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4712 }
4713 arg1 = (PLGraphicsIn *)(argp1);
4714 result = (PLINT) ((arg1)->subwindow);
4715 resultobj = SWIG_From_int((int)(result));
4716 return resultobj;
4717fail:
4718 return NULL;
4719}
4720
4721
4722SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args) {
4723 PyObject *resultobj = 0;
4724 PLGraphicsIn *arg1 = 0 ;
4725 char *arg2 = (char *)0 ;
4726 void *argp1 = 0 ;
4727 int res1 = 0 ;
4728 char temp2[16] ;
4729 int res2 ;
4730 PyObject *swig_obj[2] ;
4731
4732 (void)self;
4733 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_string_set", 2, 2, swig_obj)) SWIG_fail;
4734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4735 if (!SWIG_IsOK(res1)) {
4736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4737 }
4738 arg1 = (PLGraphicsIn *)(argp1);
4739 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 16);
4740 if (!SWIG_IsOK(res2)) {
4741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4742 }
4743 arg2 = (char *)(temp2);
4744 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4745 else memset(arg1->string,0,16*sizeof(char));
4746 resultobj = SWIG_Py_Void();
4747 return resultobj;
4748fail:
4749 return NULL;
4750}
4751
4752
4753SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args) {
4754 PyObject *resultobj = 0;
4755 PLGraphicsIn *arg1 = 0 ;
4756 void *argp1 = 0 ;
4757 int res1 = 0 ;
4758 PyObject *swig_obj[1] ;
4759 char *result = 0 ;
4760
4761 (void)self;
4762 if (!args) SWIG_fail;
4763 swig_obj[0] = args;
4764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4765 if (!SWIG_IsOK(res1)) {
4766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4767 }
4768 arg1 = (PLGraphicsIn *)(argp1);
4769 result = (char *)(char *) ((arg1)->string);
4770 {
4771 size_t size = SWIG_strnlen(result, 16);
4772
4773
4774
4775 resultobj = SWIG_FromCharPtrAndSize(result, size);
4776 }
4777 return resultobj;
4778fail:
4779 return NULL;
4780}
4781
4782
4783SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args) {
4784 PyObject *resultobj = 0;
4785 PLGraphicsIn *arg1 = 0 ;
4786 int arg2 ;
4787 void *argp1 = 0 ;
4788 int res1 = 0 ;
4789 int val2 ;
4790 int ecode2 = 0 ;
4791 PyObject *swig_obj[2] ;
4792
4793 (void)self;
4794 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pX_set", 2, 2, swig_obj)) SWIG_fail;
4795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4796 if (!SWIG_IsOK(res1)) {
4797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4798 }
4799 arg1 = (PLGraphicsIn *)(argp1);
4800 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4801 if (!SWIG_IsOK(ecode2)) {
4802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4803 }
4804 arg2 = (int)(val2);
4805 if (arg1) (arg1)->pX = arg2;
4806 resultobj = SWIG_Py_Void();
4807 return resultobj;
4808fail:
4809 return NULL;
4810}
4811
4812
4813SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args) {
4814 PyObject *resultobj = 0;
4815 PLGraphicsIn *arg1 = 0 ;
4816 void *argp1 = 0 ;
4817 int res1 = 0 ;
4818 PyObject *swig_obj[1] ;
4819 int result;
4820
4821 (void)self;
4822 if (!args) SWIG_fail;
4823 swig_obj[0] = args;
4824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4825 if (!SWIG_IsOK(res1)) {
4826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4827 }
4828 arg1 = (PLGraphicsIn *)(argp1);
4829 result = (int) ((arg1)->pX);
4830 resultobj = SWIG_From_int((int)(result));
4831 return resultobj;
4832fail:
4833 return NULL;
4834}
4835
4836
4837SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args) {
4838 PyObject *resultobj = 0;
4839 PLGraphicsIn *arg1 = 0 ;
4840 int arg2 ;
4841 void *argp1 = 0 ;
4842 int res1 = 0 ;
4843 int val2 ;
4844 int ecode2 = 0 ;
4845 PyObject *swig_obj[2] ;
4846
4847 (void)self;
4848 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pY_set", 2, 2, swig_obj)) SWIG_fail;
4849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4850 if (!SWIG_IsOK(res1)) {
4851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4852 }
4853 arg1 = (PLGraphicsIn *)(argp1);
4854 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4855 if (!SWIG_IsOK(ecode2)) {
4856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4857 }
4858 arg2 = (int)(val2);
4859 if (arg1) (arg1)->pY = arg2;
4860 resultobj = SWIG_Py_Void();
4861 return resultobj;
4862fail:
4863 return NULL;
4864}
4865
4866
4867SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args) {
4868 PyObject *resultobj = 0;
4869 PLGraphicsIn *arg1 = 0 ;
4870 void *argp1 = 0 ;
4871 int res1 = 0 ;
4872 PyObject *swig_obj[1] ;
4873 int result;
4874
4875 (void)self;
4876 if (!args) SWIG_fail;
4877 swig_obj[0] = args;
4878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4879 if (!SWIG_IsOK(res1)) {
4880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4881 }
4882 arg1 = (PLGraphicsIn *)(argp1);
4883 result = (int) ((arg1)->pY);
4884 resultobj = SWIG_From_int((int)(result));
4885 return resultobj;
4886fail:
4887 return NULL;
4888}
4889
4890
4891SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args) {
4892 PyObject *resultobj = 0;
4893 PLGraphicsIn *arg1 = 0 ;
4894 PLFLT arg2 ;
4895 void *argp1 = 0 ;
4896 int res1 = 0 ;
4897 double val2 ;
4898 int ecode2 = 0 ;
4899 PyObject *swig_obj[2] ;
4900
4901 (void)self;
4902 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dX_set", 2, 2, swig_obj)) SWIG_fail;
4903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4904 if (!SWIG_IsOK(res1)) {
4905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4906 }
4907 arg1 = (PLGraphicsIn *)(argp1);
4908 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4909 if (!SWIG_IsOK(ecode2)) {
4910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4911 }
4912 arg2 = (PLFLT)(val2);
4913 if (arg1) (arg1)->dX = arg2;
4914 resultobj = SWIG_Py_Void();
4915 return resultobj;
4916fail:
4917 return NULL;
4918}
4919
4920
4921SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args) {
4922 PyObject *resultobj = 0;
4923 PLGraphicsIn *arg1 = 0 ;
4924 void *argp1 = 0 ;
4925 int res1 = 0 ;
4926 PyObject *swig_obj[1] ;
4927 PLFLT result;
4928
4929 (void)self;
4930 if (!args) SWIG_fail;
4931 swig_obj[0] = args;
4932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4933 if (!SWIG_IsOK(res1)) {
4934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4935 }
4936 arg1 = (PLGraphicsIn *)(argp1);
4937 result = (PLFLT) ((arg1)->dX);
4938 resultobj = SWIG_From_double((double)(result));
4939 return resultobj;
4940fail:
4941 return NULL;
4942}
4943
4944
4945SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args) {
4946 PyObject *resultobj = 0;
4947 PLGraphicsIn *arg1 = 0 ;
4948 PLFLT arg2 ;
4949 void *argp1 = 0 ;
4950 int res1 = 0 ;
4951 double val2 ;
4952 int ecode2 = 0 ;
4953 PyObject *swig_obj[2] ;
4954
4955 (void)self;
4956 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dY_set", 2, 2, swig_obj)) SWIG_fail;
4957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4958 if (!SWIG_IsOK(res1)) {
4959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4960 }
4961 arg1 = (PLGraphicsIn *)(argp1);
4962 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4963 if (!SWIG_IsOK(ecode2)) {
4964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4965 }
4966 arg2 = (PLFLT)(val2);
4967 if (arg1) (arg1)->dY = arg2;
4968 resultobj = SWIG_Py_Void();
4969 return resultobj;
4970fail:
4971 return NULL;
4972}
4973
4974
4975SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args) {
4976 PyObject *resultobj = 0;
4977 PLGraphicsIn *arg1 = 0 ;
4978 void *argp1 = 0 ;
4979 int res1 = 0 ;
4980 PyObject *swig_obj[1] ;
4981 PLFLT result;
4982
4983 (void)self;
4984 if (!args) SWIG_fail;
4985 swig_obj[0] = args;
4986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4987 if (!SWIG_IsOK(res1)) {
4988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4989 }
4990 arg1 = (PLGraphicsIn *)(argp1);
4991 result = (PLFLT) ((arg1)->dY);
4992 resultobj = SWIG_From_double((double)(result));
4993 return resultobj;
4994fail:
4995 return NULL;
4996}
4997
4998
4999SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args) {
5000 PyObject *resultobj = 0;
5001 PLGraphicsIn *arg1 = 0 ;
5002 PLFLT arg2 ;
5003 void *argp1 = 0 ;
5004 int res1 = 0 ;
5005 double val2 ;
5006 int ecode2 = 0 ;
5007 PyObject *swig_obj[2] ;
5008
5009 (void)self;
5010 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wX_set", 2, 2, swig_obj)) SWIG_fail;
5011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5012 if (!SWIG_IsOK(res1)) {
5013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5014 }
5015 arg1 = (PLGraphicsIn *)(argp1);
5016 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5017 if (!SWIG_IsOK(ecode2)) {
5018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
5019 }
5020 arg2 = (PLFLT)(val2);
5021 if (arg1) (arg1)->wX = arg2;
5022 resultobj = SWIG_Py_Void();
5023 return resultobj;
5024fail:
5025 return NULL;
5026}
5027
5028
5029SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args) {
5030 PyObject *resultobj = 0;
5031 PLGraphicsIn *arg1 = 0 ;
5032 void *argp1 = 0 ;
5033 int res1 = 0 ;
5034 PyObject *swig_obj[1] ;
5035 PLFLT result;
5036
5037 (void)self;
5038 if (!args) SWIG_fail;
5039 swig_obj[0] = args;
5040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5041 if (!SWIG_IsOK(res1)) {
5042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5043 }
5044 arg1 = (PLGraphicsIn *)(argp1);
5045 result = (PLFLT) ((arg1)->wX);
5046 resultobj = SWIG_From_double((double)(result));
5047 return resultobj;
5048fail:
5049 return NULL;
5050}
5051
5052
5053SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args) {
5054 PyObject *resultobj = 0;
5055 PLGraphicsIn *arg1 = 0 ;
5056 PLFLT arg2 ;
5057 void *argp1 = 0 ;
5058 int res1 = 0 ;
5059 double val2 ;
5060 int ecode2 = 0 ;
5061 PyObject *swig_obj[2] ;
5062
5063 (void)self;
5064 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wY_set", 2, 2, swig_obj)) SWIG_fail;
5065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5066 if (!SWIG_IsOK(res1)) {
5067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5068 }
5069 arg1 = (PLGraphicsIn *)(argp1);
5070 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5071 if (!SWIG_IsOK(ecode2)) {
5072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
5073 }
5074 arg2 = (PLFLT)(val2);
5075 if (arg1) (arg1)->wY = arg2;
5076 resultobj = SWIG_Py_Void();
5077 return resultobj;
5078fail:
5079 return NULL;
5080}
5081
5082
5083SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args) {
5084 PyObject *resultobj = 0;
5085 PLGraphicsIn *arg1 = 0 ;
5086 void *argp1 = 0 ;
5087 int res1 = 0 ;
5088 PyObject *swig_obj[1] ;
5089 PLFLT result;
5090
5091 (void)self;
5092 if (!args) SWIG_fail;
5093 swig_obj[0] = args;
5094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5095 if (!SWIG_IsOK(res1)) {
5096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5097 }
5098 arg1 = (PLGraphicsIn *)(argp1);
5099 result = (PLFLT) ((arg1)->wY);
5100 resultobj = SWIG_From_double((double)(result));
5101 return resultobj;
5102fail:
5103 return NULL;
5104}
5105
5106
5107SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *self, PyObject *args) {
5108 PyObject *resultobj = 0;
5109 PLGraphicsIn *result = 0 ;
5110
5111 (void)self;
5112 if (!SWIG_Python_UnpackTuple(args, "new_PLGraphicsIn", 0, 0, 0)) SWIG_fail;
5113 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
5115 return resultobj;
5116fail:
5117 return NULL;
5118}
5119
5120
5121SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args) {
5122 PyObject *resultobj = 0;
5123 PLGraphicsIn *arg1 = 0 ;
5124 void *argp1 = 0 ;
5125 int res1 = 0 ;
5126 PyObject *swig_obj[1] ;
5127
5128 (void)self;
5129 if (!args) SWIG_fail;
5130 swig_obj[0] = args;
5131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
5132 if (!SWIG_IsOK(res1)) {
5133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5134 }
5135 arg1 = (PLGraphicsIn *)(argp1);
5136 free((char *) arg1);
5137 resultobj = SWIG_Py_Void();
5138 return resultobj;
5139fail:
5140 return NULL;
5141}
5142
5143
5144SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5145 PyObject *obj = NULL;
5146 if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
5148 return SWIG_Py_Void();
5149}
5150
5151SWIGINTERN PyObject *PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5152 return SWIG_Python_InitShadowInstance(args);
5153}
5154
5155SWIGINTERN PyObject *_wrap_plsxwin(PyObject *self, PyObject *args) {
5156 PyObject *resultobj = 0;
5157 PLINT arg1 ;
5158 int val1 ;
5159 int ecode1 = 0 ;
5160 PyObject *swig_obj[1] ;
5161
5162 (void)self;
5163 if (!args) SWIG_fail;
5164 swig_obj[0] = args;
5165 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5166 if (!SWIG_IsOK(ecode1)) {
5167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
5168 }
5169 arg1 = (PLINT)(val1);
5170 plsxwin(arg1);
5171 resultobj = SWIG_Py_Void();
5172 return resultobj;
5173fail:
5174 return NULL;
5175}
5176
5177
5178SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *self, PyObject *args) {
5179 PyObject *resultobj = 0;
5180 PLINT arg1 ;
5181 PLINT arg2 ;
5182 int val1 ;
5183 int ecode1 = 0 ;
5184 int val2 ;
5185 int ecode2 = 0 ;
5186 PyObject *swig_obj[2] ;
5187
5188 (void)self;
5189 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelformat", 2, 2, swig_obj)) SWIG_fail;
5190 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5191 if (!SWIG_IsOK(ecode1)) {
5192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
5193 }
5194 arg1 = (PLINT)(val1);
5195 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5196 if (!SWIG_IsOK(ecode2)) {
5197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
5198 }
5199 arg2 = (PLINT)(val2);
5200 pl_setcontlabelformat(arg1,arg2);
5201 resultobj = SWIG_Py_Void();
5202 return resultobj;
5203fail:
5204 return NULL;
5205}
5206
5207
5208SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *self, PyObject *args) {
5209 PyObject *resultobj = 0;
5210 PLFLT arg1 ;
5211 PLFLT arg2 ;
5212 PLFLT arg3 ;
5213 PLINT arg4 ;
5214 double val1 ;
5215 int ecode1 = 0 ;
5216 double val2 ;
5217 int ecode2 = 0 ;
5218 double val3 ;
5219 int ecode3 = 0 ;
5220 int val4 ;
5221 int ecode4 = 0 ;
5222 PyObject *swig_obj[4] ;
5223
5224 (void)self;
5225 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelparam", 4, 4, swig_obj)) SWIG_fail;
5226 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5227 if (!SWIG_IsOK(ecode1)) {
5228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
5229 }
5230 arg1 = (PLFLT)(val1);
5231 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5232 if (!SWIG_IsOK(ecode2)) {
5233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
5234 }
5235 arg2 = (PLFLT)(val2);
5236 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5237 if (!SWIG_IsOK(ecode3)) {
5238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
5239 }
5240 arg3 = (PLFLT)(val3);
5241 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5242 if (!SWIG_IsOK(ecode4)) {
5243 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
5244 }
5245 arg4 = (PLINT)(val4);
5246 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
5247 resultobj = SWIG_Py_Void();
5248 return resultobj;
5249fail:
5250 return NULL;
5251}
5252
5253
5254SWIGINTERN PyObject *_wrap_pladv(PyObject *self, PyObject *args) {
5255 PyObject *resultobj = 0;
5256 PLINT arg1 ;
5257 int val1 ;
5258 int ecode1 = 0 ;
5259 PyObject *swig_obj[1] ;
5260
5261 (void)self;
5262 if (!args) SWIG_fail;
5263 swig_obj[0] = args;
5264 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5265 if (!SWIG_IsOK(ecode1)) {
5266 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
5267 }
5268 arg1 = (PLINT)(val1);
5269 pladv(arg1);
5270 resultobj = SWIG_Py_Void();
5271 return resultobj;
5272fail:
5273 return NULL;
5274}
5275
5276
5277SWIGINTERN PyObject *_wrap_plarc(PyObject *self, PyObject *args) {
5278 PyObject *resultobj = 0;
5279 PLFLT arg1 ;
5280 PLFLT arg2 ;
5281 PLFLT arg3 ;
5282 PLFLT arg4 ;
5283 PLFLT arg5 ;
5284 PLFLT arg6 ;
5285 PLFLT arg7 ;
5286 PLBOOL arg8 ;
5287 double val1 ;
5288 int ecode1 = 0 ;
5289 double val2 ;
5290 int ecode2 = 0 ;
5291 double val3 ;
5292 int ecode3 = 0 ;
5293 double val4 ;
5294 int ecode4 = 0 ;
5295 double val5 ;
5296 int ecode5 = 0 ;
5297 double val6 ;
5298 int ecode6 = 0 ;
5299 double val7 ;
5300 int ecode7 = 0 ;
5301 int val8 ;
5302 int ecode8 = 0 ;
5303 PyObject *swig_obj[8] ;
5304
5305 (void)self;
5306 if (!SWIG_Python_UnpackTuple(args, "plarc", 8, 8, swig_obj)) SWIG_fail;
5307 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5308 if (!SWIG_IsOK(ecode1)) {
5309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
5310 }
5311 arg1 = (PLFLT)(val1);
5312 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5313 if (!SWIG_IsOK(ecode2)) {
5314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
5315 }
5316 arg2 = (PLFLT)(val2);
5317 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5318 if (!SWIG_IsOK(ecode3)) {
5319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
5320 }
5321 arg3 = (PLFLT)(val3);
5322 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5323 if (!SWIG_IsOK(ecode4)) {
5324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
5325 }
5326 arg4 = (PLFLT)(val4);
5327 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5328 if (!SWIG_IsOK(ecode5)) {
5329 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
5330 }
5331 arg5 = (PLFLT)(val5);
5332 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5333 if (!SWIG_IsOK(ecode6)) {
5334 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
5335 }
5336 arg6 = (PLFLT)(val6);
5337 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5338 if (!SWIG_IsOK(ecode7)) {
5339 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
5340 }
5341 arg7 = (PLFLT)(val7);
5342 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5343 if (!SWIG_IsOK(ecode8)) {
5344 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
5345 }
5346 arg8 = (PLBOOL)(val8);
5347 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5348 resultobj = SWIG_Py_Void();
5349 return resultobj;
5350fail:
5351 return NULL;
5352}
5353
5354
5355SWIGINTERN PyObject *_wrap_plaxes(PyObject *self, PyObject *args) {
5356 PyObject *resultobj = 0;
5357 PLFLT arg1 ;
5358 PLFLT arg2 ;
5359 char *arg3 = 0 ;
5360 PLFLT arg4 ;
5361 PLINT arg5 ;
5362 char *arg6 = 0 ;
5363 PLFLT arg7 ;
5364 PLINT arg8 ;
5365 double val1 ;
5366 int ecode1 = 0 ;
5367 double val2 ;
5368 int ecode2 = 0 ;
5369 int res3 ;
5370 char *buf3 = 0 ;
5371 int alloc3 = 0 ;
5372 double val4 ;
5373 int ecode4 = 0 ;
5374 int val5 ;
5375 int ecode5 = 0 ;
5376 int res6 ;
5377 char *buf6 = 0 ;
5378 int alloc6 = 0 ;
5379 double val7 ;
5380 int ecode7 = 0 ;
5381 int val8 ;
5382 int ecode8 = 0 ;
5383 PyObject *swig_obj[8] ;
5384
5385 (void)self;
5386 if (!SWIG_Python_UnpackTuple(args, "plaxes", 8, 8, swig_obj)) SWIG_fail;
5387 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5388 if (!SWIG_IsOK(ecode1)) {
5389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5390 }
5391 arg1 = (PLFLT)(val1);
5392 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5393 if (!SWIG_IsOK(ecode2)) {
5394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5395 }
5396 arg2 = (PLFLT)(val2);
5397 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
5398 if (!SWIG_IsOK(res3)) {
5399 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5400 }
5401 arg3 = (char *)(buf3);
5402 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5403 if (!SWIG_IsOK(ecode4)) {
5404 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5405 }
5406 arg4 = (PLFLT)(val4);
5407 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5408 if (!SWIG_IsOK(ecode5)) {
5409 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5410 }
5411 arg5 = (PLINT)(val5);
5412 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5413 if (!SWIG_IsOK(res6)) {
5414 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5415 }
5416 arg6 = (char *)(buf6);
5417 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5418 if (!SWIG_IsOK(ecode7)) {
5419 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5420 }
5421 arg7 = (PLFLT)(val7);
5422 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5423 if (!SWIG_IsOK(ecode8)) {
5424 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5425 }
5426 arg8 = (PLINT)(val8);
5427 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5428 resultobj = SWIG_Py_Void();
5429 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5430 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5431 return resultobj;
5432fail:
5433 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5434 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5435 return NULL;
5436}
5437
5438
5439SWIGINTERN PyObject *_wrap_plbin(PyObject *self, PyObject *args) {
5440 PyObject *resultobj = 0;
5441 PLINT arg1 ;
5442 PLFLT *arg2 = 0 ;
5443 PLFLT *arg3 = 0 ;
5444 PLINT arg4 ;
5445 PyArrayObject *tmp1 = NULL ;
5446 PyArrayObject *tmp3 = NULL ;
5447 int val4 ;
5448 int ecode4 = 0 ;
5449 PyObject *swig_obj[3] ;
5450
5451 (void)self;
5452 if (!SWIG_Python_UnpackTuple(args, "plbin", 3, 3, swig_obj)) SWIG_fail;
5453 {
5454 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5455 if ( tmp1 == NULL )
5456 return NULL;
5457 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5458 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5459 }
5460 {
5461 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5462 if ( tmp3 == NULL )
5463 return NULL;
5464 if ( PyArray_DIMS( tmp3 )[0] != Alen )
5465 {
5466 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5467 return NULL;
5468 }
5469 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5470 }
5471 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
5472 if (!SWIG_IsOK(ecode4)) {
5473 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5474 }
5475 arg4 = (PLINT)(val4);
5476 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5477 resultobj = SWIG_Py_Void();
5478 {
5479 Py_CLEAR( tmp1 );
5480 }
5481 {
5482 Py_CLEAR( tmp3 );
5483 }
5484 return resultobj;
5485fail:
5486 {
5487 Py_CLEAR( tmp1 );
5488 }
5489 {
5490 Py_CLEAR( tmp3 );
5491 }
5492 return NULL;
5493}
5494
5495
5496SWIGINTERN PyObject *_wrap_plbtime(PyObject *self, PyObject *args) {
5497 PyObject *resultobj = 0;
5498 PLINT *arg1 = 0 ;
5499 PLINT *arg2 = 0 ;
5500 PLINT *arg3 = 0 ;
5501 PLINT *arg4 = 0 ;
5502 PLINT *arg5 = 0 ;
5503 PLFLT *arg6 = 0 ;
5504 PLFLT arg7 ;
5505 PLINT temp1 ;
5506 int res1 = SWIG_TMPOBJ ;
5507 PLINT temp2 ;
5508 int res2 = SWIG_TMPOBJ ;
5509 PLINT temp3 ;
5510 int res3 = SWIG_TMPOBJ ;
5511 PLINT temp4 ;
5512 int res4 = SWIG_TMPOBJ ;
5513 PLINT temp5 ;
5514 int res5 = SWIG_TMPOBJ ;
5515 PLFLT temp6 ;
5516 int res6 = SWIG_TMPOBJ ;
5517 double val7 ;
5518 int ecode7 = 0 ;
5519 PyObject *swig_obj[1] ;
5520
5521 arg1 = &temp1;
5522 arg2 = &temp2;
5523 arg3 = &temp3;
5524 arg4 = &temp4;
5525 arg5 = &temp5;
5526 arg6 = &temp6;
5527 (void)self;
5528 if (!args) SWIG_fail;
5529 swig_obj[0] = args;
5530 ecode7 = SWIG_AsVal_double(swig_obj[0], &val7);
5531 if (!SWIG_IsOK(ecode7)) {
5532 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5533 }
5534 arg7 = (PLFLT)(val7);
5535 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5536 resultobj = SWIG_Py_Void();
5537 if (SWIG_IsTmpObj(res1)) {
5538 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
5539 } else {
5540 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
5542 }
5543 if (SWIG_IsTmpObj(res2)) {
5544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
5545 } else {
5546 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
5548 }
5549 if (SWIG_IsTmpObj(res3)) {
5550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
5551 } else {
5552 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
5554 }
5555 if (SWIG_IsTmpObj(res4)) {
5556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
5557 } else {
5558 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
5560 }
5561 if (SWIG_IsTmpObj(res5)) {
5562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
5563 } else {
5564 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
5566 }
5567 if (SWIG_IsTmpObj(res6)) {
5568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 1);
5569 } else {
5570 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 1);
5572 }
5573 return resultobj;
5574fail:
5575 return NULL;
5576}
5577
5578
5579SWIGINTERN PyObject *_wrap_plbop(PyObject *self, PyObject *args) {
5580 PyObject *resultobj = 0;
5581
5582 (void)self;
5583 if (!SWIG_Python_UnpackTuple(args, "plbop", 0, 0, 0)) SWIG_fail;
5584 plbop();
5585 resultobj = SWIG_Py_Void();
5586 return resultobj;
5587fail:
5588 return NULL;
5589}
5590
5591
5592SWIGINTERN PyObject *_wrap_plbox(PyObject *self, PyObject *args) {
5593 PyObject *resultobj = 0;
5594 char *arg1 = 0 ;
5595 PLFLT arg2 ;
5596 PLINT arg3 ;
5597 char *arg4 = 0 ;
5598 PLFLT arg5 ;
5599 PLINT arg6 ;
5600 int res1 ;
5601 char *buf1 = 0 ;
5602 int alloc1 = 0 ;
5603 double val2 ;
5604 int ecode2 = 0 ;
5605 int val3 ;
5606 int ecode3 = 0 ;
5607 int res4 ;
5608 char *buf4 = 0 ;
5609 int alloc4 = 0 ;
5610 double val5 ;
5611 int ecode5 = 0 ;
5612 int val6 ;
5613 int ecode6 = 0 ;
5614 PyObject *swig_obj[6] ;
5615
5616 (void)self;
5617 if (!SWIG_Python_UnpackTuple(args, "plbox", 6, 6, swig_obj)) SWIG_fail;
5618 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5619 if (!SWIG_IsOK(res1)) {
5620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5621 }
5622 arg1 = (char *)(buf1);
5623 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5624 if (!SWIG_IsOK(ecode2)) {
5625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5626 }
5627 arg2 = (PLFLT)(val2);
5628 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5629 if (!SWIG_IsOK(ecode3)) {
5630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5631 }
5632 arg3 = (PLINT)(val3);
5633 res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
5634 if (!SWIG_IsOK(res4)) {
5635 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5636 }
5637 arg4 = (char *)(buf4);
5638 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5639 if (!SWIG_IsOK(ecode5)) {
5640 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5641 }
5642 arg5 = (PLFLT)(val5);
5643 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5644 if (!SWIG_IsOK(ecode6)) {
5645 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5646 }
5647 arg6 = (PLINT)(val6);
5648 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5649 resultobj = SWIG_Py_Void();
5650 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5651 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5652 return resultobj;
5653fail:
5654 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5655 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5656 return NULL;
5657}
5658
5659
5660SWIGINTERN PyObject *_wrap_plbox3(PyObject *self, PyObject *args) {
5661 PyObject *resultobj = 0;
5662 char *arg1 = 0 ;
5663 char *arg2 = 0 ;
5664 PLFLT arg3 ;
5665 PLINT arg4 ;
5666 char *arg5 = 0 ;
5667 char *arg6 = 0 ;
5668 PLFLT arg7 ;
5669 PLINT arg8 ;
5670 char *arg9 = 0 ;
5671 char *arg10 = 0 ;
5672 PLFLT arg11 ;
5673 PLINT arg12 ;
5674 int res1 ;
5675 char *buf1 = 0 ;
5676 int alloc1 = 0 ;
5677 int res2 ;
5678 char *buf2 = 0 ;
5679 int alloc2 = 0 ;
5680 double val3 ;
5681 int ecode3 = 0 ;
5682 int val4 ;
5683 int ecode4 = 0 ;
5684 int res5 ;
5685 char *buf5 = 0 ;
5686 int alloc5 = 0 ;
5687 int res6 ;
5688 char *buf6 = 0 ;
5689 int alloc6 = 0 ;
5690 double val7 ;
5691 int ecode7 = 0 ;
5692 int val8 ;
5693 int ecode8 = 0 ;
5694 int res9 ;
5695 char *buf9 = 0 ;
5696 int alloc9 = 0 ;
5697 int res10 ;
5698 char *buf10 = 0 ;
5699 int alloc10 = 0 ;
5700 double val11 ;
5701 int ecode11 = 0 ;
5702 int val12 ;
5703 int ecode12 = 0 ;
5704 PyObject *swig_obj[12] ;
5705
5706 (void)self;
5707 if (!SWIG_Python_UnpackTuple(args, "plbox3", 12, 12, swig_obj)) SWIG_fail;
5708 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5709 if (!SWIG_IsOK(res1)) {
5710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5711 }
5712 arg1 = (char *)(buf1);
5713 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
5714 if (!SWIG_IsOK(res2)) {
5715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5716 }
5717 arg2 = (char *)(buf2);
5718 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5719 if (!SWIG_IsOK(ecode3)) {
5720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5721 }
5722 arg3 = (PLFLT)(val3);
5723 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5724 if (!SWIG_IsOK(ecode4)) {
5725 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5726 }
5727 arg4 = (PLINT)(val4);
5728 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
5729 if (!SWIG_IsOK(res5)) {
5730 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5731 }
5732 arg5 = (char *)(buf5);
5733 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5734 if (!SWIG_IsOK(res6)) {
5735 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5736 }
5737 arg6 = (char *)(buf6);
5738 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5739 if (!SWIG_IsOK(ecode7)) {
5740 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5741 }
5742 arg7 = (PLFLT)(val7);
5743 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5744 if (!SWIG_IsOK(ecode8)) {
5745 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5746 }
5747 arg8 = (PLINT)(val8);
5748 res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
5749 if (!SWIG_IsOK(res9)) {
5750 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5751 }
5752 arg9 = (char *)(buf9);
5753 res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
5754 if (!SWIG_IsOK(res10)) {
5755 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5756 }
5757 arg10 = (char *)(buf10);
5758 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5759 if (!SWIG_IsOK(ecode11)) {
5760 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5761 }
5762 arg11 = (PLFLT)(val11);
5763 ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
5764 if (!SWIG_IsOK(ecode12)) {
5765 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5766 }
5767 arg12 = (PLINT)(val12);
5768 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);
5769 resultobj = SWIG_Py_Void();
5770 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5771 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5772 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5773 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5774 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5775 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5776 return resultobj;
5777fail:
5778 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5779 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5780 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5781 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5782 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5783 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5784 return NULL;
5785}
5786
5787
5788SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *self, PyObject *args) {
5789 PyObject *resultobj = 0;
5790 PLFLT arg1 ;
5791 PLFLT arg2 ;
5792 PLFLT *arg3 = 0 ;
5793 PLFLT *arg4 = 0 ;
5794 PLINT *arg5 = 0 ;
5795 double val1 ;
5796 int ecode1 = 0 ;
5797 double val2 ;
5798 int ecode2 = 0 ;
5799 PLFLT temp3 ;
5800 int res3 = SWIG_TMPOBJ ;
5801 PLFLT temp4 ;
5802 int res4 = SWIG_TMPOBJ ;
5803 PLINT temp5 ;
5804 int res5 = SWIG_TMPOBJ ;
5805 PyObject *swig_obj[2] ;
5806
5807 arg3 = &temp3;
5808 arg4 = &temp4;
5809 arg5 = &temp5;
5810 (void)self;
5811 if (!SWIG_Python_UnpackTuple(args, "plcalc_world", 2, 2, swig_obj)) SWIG_fail;
5812 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5813 if (!SWIG_IsOK(ecode1)) {
5814 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5815 }
5816 arg1 = (PLFLT)(val1);
5817 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5818 if (!SWIG_IsOK(ecode2)) {
5819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5820 }
5821 arg2 = (PLFLT)(val2);
5822 plcalc_world(arg1,arg2,arg3,arg4,arg5);
5823 resultobj = SWIG_Py_Void();
5824 if (SWIG_IsTmpObj(res3)) {
5825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
5826 } else {
5827 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
5829 }
5830 if (SWIG_IsTmpObj(res4)) {
5831 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
5832 } else {
5833 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5834 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
5835 }
5836 if (SWIG_IsTmpObj(res5)) {
5837 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
5838 } else {
5839 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5840 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
5841 }
5842 return resultobj;
5843fail:
5844 return NULL;
5845}
5846
5847
5848SWIGINTERN PyObject *_wrap_plclear(PyObject *self, PyObject *args) {
5849 PyObject *resultobj = 0;
5850
5851 (void)self;
5852 if (!SWIG_Python_UnpackTuple(args, "plclear", 0, 0, 0)) SWIG_fail;
5853 plclear();
5854 resultobj = SWIG_Py_Void();
5855 return resultobj;
5856fail:
5857 return NULL;
5858}
5859
5860
5861SWIGINTERN PyObject *_wrap_plcol0(PyObject *self, PyObject *args) {
5862 PyObject *resultobj = 0;
5863 PLINT arg1 ;
5864 int val1 ;
5865 int ecode1 = 0 ;
5866 PyObject *swig_obj[1] ;
5867
5868 (void)self;
5869 if (!args) SWIG_fail;
5870 swig_obj[0] = args;
5871 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5872 if (!SWIG_IsOK(ecode1)) {
5873 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5874 }
5875 arg1 = (PLINT)(val1);
5876 plcol0(arg1);
5877 resultobj = SWIG_Py_Void();
5878 return resultobj;
5879fail:
5880 return NULL;
5881}
5882
5883
5884SWIGINTERN PyObject *_wrap_plcol1(PyObject *self, PyObject *args) {
5885 PyObject *resultobj = 0;
5886 PLFLT arg1 ;
5887 double val1 ;
5888 int ecode1 = 0 ;
5889 PyObject *swig_obj[1] ;
5890
5891 (void)self;
5892 if (!args) SWIG_fail;
5893 swig_obj[0] = args;
5894 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5895 if (!SWIG_IsOK(ecode1)) {
5896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5897 }
5898 arg1 = (PLFLT)(val1);
5899 plcol1(arg1);
5900 resultobj = SWIG_Py_Void();
5901 return resultobj;
5902fail:
5903 return NULL;
5904}
5905
5906
5907SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *self, PyObject *args) {
5908 PyObject *resultobj = 0;
5909 PLFLT arg1 ;
5910 PLFLT arg2 ;
5911 PLFLT arg3 ;
5912 PLINT arg4 ;
5913 PLBOOL arg5 ;
5914 PLINT arg6 ;
5915 PLINT arg7 ;
5916 PLINT arg8 ;
5917 PLINT arg9 ;
5918 PLINT arg10 ;
5919 PLFLT arg11 ;
5920 double val1 ;
5921 int ecode1 = 0 ;
5922 double val2 ;
5923 int ecode2 = 0 ;
5924 double val3 ;
5925 int ecode3 = 0 ;
5926 int val4 ;
5927 int ecode4 = 0 ;
5928 int val5 ;
5929 int ecode5 = 0 ;
5930 int val6 ;
5931 int ecode6 = 0 ;
5932 int val7 ;
5933 int ecode7 = 0 ;
5934 int val8 ;
5935 int ecode8 = 0 ;
5936 int val9 ;
5937 int ecode9 = 0 ;
5938 int val10 ;
5939 int ecode10 = 0 ;
5940 double val11 ;
5941 int ecode11 = 0 ;
5942 PyObject *swig_obj[11] ;
5943
5944 (void)self;
5945 if (!SWIG_Python_UnpackTuple(args, "plconfigtime", 11, 11, swig_obj)) SWIG_fail;
5946 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5947 if (!SWIG_IsOK(ecode1)) {
5948 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5949 }
5950 arg1 = (PLFLT)(val1);
5951 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5952 if (!SWIG_IsOK(ecode2)) {
5953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5954 }
5955 arg2 = (PLFLT)(val2);
5956 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5957 if (!SWIG_IsOK(ecode3)) {
5958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5959 }
5960 arg3 = (PLFLT)(val3);
5961 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5962 if (!SWIG_IsOK(ecode4)) {
5963 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5964 }
5965 arg4 = (PLINT)(val4);
5966 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5967 if (!SWIG_IsOK(ecode5)) {
5968 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5969 }
5970 arg5 = (PLBOOL)(val5);
5971 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5972 if (!SWIG_IsOK(ecode6)) {
5973 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5974 }
5975 arg6 = (PLINT)(val6);
5976 ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
5977 if (!SWIG_IsOK(ecode7)) {
5978 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5979 }
5980 arg7 = (PLINT)(val7);
5981 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5982 if (!SWIG_IsOK(ecode8)) {
5983 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5984 }
5985 arg8 = (PLINT)(val8);
5986 ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
5987 if (!SWIG_IsOK(ecode9)) {
5988 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5989 }
5990 arg9 = (PLINT)(val9);
5991 ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
5992 if (!SWIG_IsOK(ecode10)) {
5993 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5994 }
5995 arg10 = (PLINT)(val10);
5996 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5997 if (!SWIG_IsOK(ecode11)) {
5998 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5999 }
6000 arg11 = (PLFLT)(val11);
6001 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
6002 resultobj = SWIG_Py_Void();
6003 return resultobj;
6004fail:
6005 return NULL;
6006}
6007
6008
6009SWIGINTERN PyObject *_wrap_plcont(PyObject *self, PyObject *args) {
6010 PyObject *resultobj = 0;
6011 PLFLT **arg1 = 0 ;
6012 PLINT arg2 ;
6013 PLINT arg3 ;
6014 PLINT arg4 ;
6015 PLINT arg5 ;
6016 PLINT arg6 ;
6017 PLINT arg7 ;
6018 PLFLT *arg8 = 0 ;
6019 PLINT arg9 ;
6020 pltr_func arg10 = 0 ;
6021 PLPointer arg11 = 0 ;
6022 PyArrayObject *tmp1 = NULL ;
6023 int val4 ;
6024 int ecode4 = 0 ;
6025 int val5 ;
6026 int ecode5 = 0 ;
6027 int val6 ;
6028 int ecode6 = 0 ;
6029 int val7 ;
6030 int ecode7 = 0 ;
6031 PyArrayObject *tmp8 = NULL ;
6032 PyObject *swig_obj[8] ;
6033
6034 {
6035 python_pltr = 0;
6036 arg10 = NULL;
6037 }
6038 {
6039 arg11 = NULL;
6040 }
6041 (void)self;
6042 if (!SWIG_Python_UnpackTuple(args, "plcont", 6, 8, swig_obj)) SWIG_fail;
6043 {
6044 int i, size;
6045 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
6046 if ( tmp1 == NULL )
6047 return NULL;
6048 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
6049 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
6050 size = arg3;
6051 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
6052 for ( i = 0; i < arg2; i++ )
6053 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
6054 }
6055 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
6056 if (!SWIG_IsOK(ecode4)) {
6057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
6058 }
6059 arg4 = (PLINT)(val4);
6060 ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
6061 if (!SWIG_IsOK(ecode5)) {
6062 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
6063 }
6064 arg5 = (PLINT)(val5);
6065 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
6066 if (!SWIG_IsOK(ecode6)) {
6067 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
6068 }
6069 arg6 = (PLINT)(val6);
6070 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
6071 if (!SWIG_IsOK(ecode7)) {
6072 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
6073 }
6074 arg7 = (PLINT)(val7);
6075 {
6076 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
6077 if ( tmp8 == NULL )
6078 return NULL;
6079 arg9 = PyArray_DIMS( tmp8 )[0];
6080 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
6081 }
6082 if (swig_obj[6]) {
6083 {
6084 // it must be a callable or None
6085 if ( swig_obj[6] == Py_None )
6086 {
6087 arg10 = NULL;
6088 }
6089 else
6090 {
6091 if ( !PyCallable_Check( (PyObject *) swig_obj[6] ) )
6092 {
6093 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
6094 return NULL;
6095 }
6096 arg10 = marshal_pltr( swig_obj[6] );
6097 }
6098 }
6099 }
6100 if (swig_obj[7]) {
6101 {
6102 if ( swig_obj[7] == Py_None )
6103 arg11 = NULL;
6104 else
6105 {
6106 arg11 = marshal_PLPointer( swig_obj[7], 0 );
6107 }
6108 }
6109 }
6110 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
6111 resultobj = SWIG_Py_Void();
6112 {
6113 Py_CLEAR( tmp1 );
6114 free( arg1 );
6115 }
6116 {
6117 Py_CLEAR( tmp8 );
6118 }
6119 {
6120 cleanup_pltr();
6121 }
6122 {
6124 }
6125 return resultobj;
6126fail:
6127 {
6128 Py_CLEAR( tmp1 );
6129 free( arg1 );
6130 }
6131 {
6132 Py_CLEAR( tmp8 );
6133 }
6134 {
6135 cleanup_pltr();
6136 }
6137 {
6139 }
6140 return NULL;
6141}
6142
6143
6144SWIGINTERN PyObject *_wrap_plctime(PyObject *self, PyObject *args) {
6145 PyObject *resultobj = 0;
6146 PLINT arg1 ;
6147 PLINT arg2 ;
6148 PLINT arg3 ;
6149 PLINT arg4 ;
6150 PLINT arg5 ;
6151 PLFLT arg6 ;
6152 PLFLT *arg7 = 0 ;
6153 int val1 ;
6154 int ecode1 = 0 ;
6155 int val2 ;
6156 int ecode2 = 0 ;
6157 int val3 ;
6158 int ecode3 = 0 ;
6159 int val4 ;
6160 int ecode4 = 0 ;
6161 int val5 ;
6162 int ecode5 = 0 ;
6163 double val6 ;
6164 int ecode6 = 0 ;
6165 PLFLT temp7 ;
6166 int res7 = SWIG_TMPOBJ ;
6167 PyObject *swig_obj[6] ;
6168
6169 arg7 = &temp7;
6170 (void)self;
6171 if (!SWIG_Python_UnpackTuple(args, "plctime", 6, 6, swig_obj)) SWIG_fail;
6172 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6173 if (!SWIG_IsOK(ecode1)) {
6174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
6175 }
6176 arg1 = (PLINT)(val1);
6177 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6178 if (!SWIG_IsOK(ecode2)) {
6179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
6180 }
6181 arg2 = (PLINT)(val2);
6182 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
6183 if (!SWIG_IsOK(ecode3)) {
6184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
6185 }
6186 arg3 = (PLINT)(val3);
6187 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
6188 if (!SWIG_IsOK(ecode4)) {
6189 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
6190 }
6191 arg4 = (PLINT)(val4);
6192 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6193 if (!SWIG_IsOK(ecode5)) {
6194 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
6195 }
6196 arg5 = (PLINT)(val5);
6197 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
6198 if (!SWIG_IsOK(ecode6)) {
6199 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
6200 }
6201 arg6 = (PLFLT)(val6);
6202 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
6203 resultobj = SWIG_Py_Void();
6204 if (SWIG_IsTmpObj(res7)) {
6205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)), 1);
6206 } else {
6207 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags), 1);
6209 }
6210 return resultobj;
6211fail:
6212 return NULL;
6213}
6214
6215
6216SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *self, PyObject *args) {
6217 PyObject *resultobj = 0;
6218 PLINT arg1 ;
6219 PLBOOL arg2 ;
6220 int val1 ;
6221 int ecode1 = 0 ;
6222 int val2 ;
6223 int ecode2 = 0 ;
6224 PyObject *swig_obj[2] ;
6225
6226 (void)self;
6227 if (!SWIG_Python_UnpackTuple(args, "plcpstrm", 2, 2, swig_obj)) SWIG_fail;
6228 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6229 if (!SWIG_IsOK(ecode1)) {
6230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
6231 }
6232 arg1 = (PLINT)(val1);
6233 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6234 if (!SWIG_IsOK(ecode2)) {
6235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
6236 }
6237 arg2 = (PLBOOL)(val2);
6238 plcpstrm(arg1,arg2);
6239 resultobj = SWIG_Py_Void();
6240 return resultobj;
6241fail:
6242 return NULL;
6243}
6244
6245
6246SWIGINTERN PyObject *_wrap_plend(PyObject *self, PyObject *args) {
6247 PyObject *resultobj = 0;
6248
6249 (void)self;
6250 if (!SWIG_Python_UnpackTuple(args, "plend", 0, 0, 0)) SWIG_fail;
6251 plend();
6252 resultobj = SWIG_Py_Void();
6253 return resultobj;
6254fail:
6255 return NULL;
6256}
6257
6258
6259SWIGINTERN PyObject *_wrap_plend1(PyObject *self, PyObject *args) {
6260 PyObject *resultobj = 0;
6261
6262 (void)self;
6263 if (!SWIG_Python_UnpackTuple(args, "plend1", 0, 0, 0)) SWIG_fail;
6264 plend1();
6265 resultobj = SWIG_Py_Void();
6266 return resultobj;
6267fail:
6268 return NULL;
6269}
6270
6271
6272SWIGINTERN PyObject *_wrap_plenv(PyObject *self, PyObject *args) {
6273 PyObject *resultobj = 0;
6274 PLFLT arg1 ;
6275 PLFLT arg2 ;
6276 PLFLT arg3 ;
6277 PLFLT arg4 ;
6278 PLINT arg5 ;
6279 PLINT arg6 ;
6280 double val1 ;
6281 int ecode1 = 0 ;
6282 double val2 ;
6283 int ecode2 = 0 ;
6284 double val3 ;
6285 int ecode3 = 0 ;
6286 double val4 ;
6287 int ecode4 = 0 ;
6288 int val5 ;
6289 int ecode5 = 0 ;
6290 int val6 ;
6291 int ecode6 = 0 ;
6292 PyObject *swig_obj[6] ;
6293
6294 (void)self;
6295 if (!SWIG_Python_UnpackTuple(args, "plenv", 6, 6, swig_obj)) SWIG_fail;
6296 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6297 if (!SWIG_IsOK(ecode1)) {
6298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
6299 }
6300 arg1 = (PLFLT)(val1);
6301 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6302 if (!SWIG_IsOK(ecode2)) {
6303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
6304 }
6305 arg2 = (PLFLT)(val2);
6306 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6307 if (!SWIG_IsOK(ecode3)) {
6308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
6309 }
6310 arg3 = (PLFLT)(val3);
6311 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6312 if (!SWIG_IsOK(ecode4)) {
6313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
6314 }
6315 arg4 = (PLFLT)(val4);
6316 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6317 if (!SWIG_IsOK(ecode5)) {
6318 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
6319 }
6320 arg5 = (PLINT)(val5);
6321 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6322 if (!SWIG_IsOK(ecode6)) {
6323 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6324 }
6325 arg6 = (PLINT)(val6);
6326 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6327 resultobj = SWIG_Py_Void();
6328 return resultobj;
6329fail:
6330 return NULL;
6331}
6332
6333
6334SWIGINTERN PyObject *_wrap_plenv0(PyObject *self, PyObject *args) {
6335 PyObject *resultobj = 0;
6336 PLFLT arg1 ;
6337 PLFLT arg2 ;
6338 PLFLT arg3 ;
6339 PLFLT arg4 ;
6340 PLINT arg5 ;
6341 PLINT arg6 ;
6342 double val1 ;
6343 int ecode1 = 0 ;
6344 double val2 ;
6345 int ecode2 = 0 ;
6346 double val3 ;
6347 int ecode3 = 0 ;
6348 double val4 ;
6349 int ecode4 = 0 ;
6350 int val5 ;
6351 int ecode5 = 0 ;
6352 int val6 ;
6353 int ecode6 = 0 ;
6354 PyObject *swig_obj[6] ;
6355
6356 (void)self;
6357 if (!SWIG_Python_UnpackTuple(args, "plenv0", 6, 6, swig_obj)) SWIG_fail;
6358 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6359 if (!SWIG_IsOK(ecode1)) {
6360 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6361 }
6362 arg1 = (PLFLT)(val1);
6363 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6364 if (!SWIG_IsOK(ecode2)) {
6365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6366 }
6367 arg2 = (PLFLT)(val2);
6368 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6369 if (!SWIG_IsOK(ecode3)) {
6370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6371 }
6372 arg3 = (PLFLT)(val3);
6373 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6374 if (!SWIG_IsOK(ecode4)) {
6375 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6376 }
6377 arg4 = (PLFLT)(val4);
6378 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6379 if (!SWIG_IsOK(ecode5)) {
6380 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6381 }
6382 arg5 = (PLINT)(val5);
6383 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6384 if (!SWIG_IsOK(ecode6)) {
6385 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6386 }
6387 arg6 = (PLINT)(val6);
6388 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6389 resultobj = SWIG_Py_Void();
6390 return resultobj;
6391fail:
6392 return NULL;
6393}
6394
6395
6396SWIGINTERN PyObject *_wrap_pleop(PyObject *self, PyObject *args) {
6397 PyObject *resultobj = 0;
6398
6399 (void)self;
6400 if (!SWIG_Python_UnpackTuple(args, "pleop", 0, 0, 0)) SWIG_fail;
6401 pleop();
6402 resultobj = SWIG_Py_Void();
6403 return resultobj;
6404fail:
6405 return NULL;
6406}
6407
6408
6409SWIGINTERN PyObject *_wrap_plerrx(PyObject *self, PyObject *args) {
6410 PyObject *resultobj = 0;
6411 PLINT arg1 ;
6412 PLFLT *arg2 = 0 ;
6413 PLFLT *arg3 = 0 ;
6414 PLFLT *arg4 = 0 ;
6415 PyArrayObject *tmp1 = NULL ;
6416 PyArrayObject *tmp3 = NULL ;
6417 PyArrayObject *tmp4 = NULL ;
6418 PyObject *swig_obj[3] ;
6419
6420 (void)self;
6421 if (!SWIG_Python_UnpackTuple(args, "plerrx", 3, 3, swig_obj)) SWIG_fail;
6422 {
6423 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6424 if ( tmp1 == NULL )
6425 return NULL;
6426 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6427 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6428 }
6429 {
6430 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6431 if ( tmp3 == NULL )
6432 return NULL;
6433 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6434 {
6435 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6436 return NULL;
6437 }
6438 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6439 }
6440 {
6441 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6442 if ( tmp4 == NULL )
6443 return NULL;
6444 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6445 {
6446 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6447 return NULL;
6448 }
6449 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6450 }
6451 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6452 resultobj = SWIG_Py_Void();
6453 {
6454 Py_CLEAR( tmp1 );
6455 }
6456 {
6457 Py_CLEAR( tmp3 );
6458 }
6459 {
6460 Py_CLEAR( tmp4 );
6461 }
6462 return resultobj;
6463fail:
6464 {
6465 Py_CLEAR( tmp1 );
6466 }
6467 {
6468 Py_CLEAR( tmp3 );
6469 }
6470 {
6471 Py_CLEAR( tmp4 );
6472 }
6473 return NULL;
6474}
6475
6476
6477SWIGINTERN PyObject *_wrap_plerry(PyObject *self, PyObject *args) {
6478 PyObject *resultobj = 0;
6479 PLINT arg1 ;
6480 PLFLT *arg2 = 0 ;
6481 PLFLT *arg3 = 0 ;
6482 PLFLT *arg4 = 0 ;
6483 PyArrayObject *tmp1 = NULL ;
6484 PyArrayObject *tmp3 = NULL ;
6485 PyArrayObject *tmp4 = NULL ;
6486 PyObject *swig_obj[3] ;
6487
6488 (void)self;
6489 if (!SWIG_Python_UnpackTuple(args, "plerry", 3, 3, swig_obj)) SWIG_fail;
6490 {
6491 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6492 if ( tmp1 == NULL )
6493 return NULL;
6494 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6495 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6496 }
6497 {
6498 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6499 if ( tmp3 == NULL )
6500 return NULL;
6501 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6502 {
6503 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6504 return NULL;
6505 }
6506 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6507 }
6508 {
6509 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6510 if ( tmp4 == NULL )
6511 return NULL;
6512 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6513 {
6514 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6515 return NULL;
6516 }
6517 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6518 }
6519 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6520 resultobj = SWIG_Py_Void();
6521 {
6522 Py_CLEAR( tmp1 );
6523 }
6524 {
6525 Py_CLEAR( tmp3 );
6526 }
6527 {
6528 Py_CLEAR( tmp4 );
6529 }
6530 return resultobj;
6531fail:
6532 {
6533 Py_CLEAR( tmp1 );
6534 }
6535 {
6536 Py_CLEAR( tmp3 );
6537 }
6538 {
6539 Py_CLEAR( tmp4 );
6540 }
6541 return NULL;
6542}
6543
6544
6545SWIGINTERN PyObject *_wrap_plfamadv(PyObject *self, PyObject *args) {
6546 PyObject *resultobj = 0;
6547
6548 (void)self;
6549 if (!SWIG_Python_UnpackTuple(args, "plfamadv", 0, 0, 0)) SWIG_fail;
6550 plfamadv();
6551 resultobj = SWIG_Py_Void();
6552 return resultobj;
6553fail:
6554 return NULL;
6555}
6556
6557
6558SWIGINTERN PyObject *_wrap_plfill(PyObject *self, PyObject *args) {
6559 PyObject *resultobj = 0;
6560 PLINT arg1 ;
6561 PLFLT *arg2 = 0 ;
6562 PLFLT *arg3 = 0 ;
6563 PyArrayObject *tmp1 = NULL ;
6564 PyArrayObject *tmp3 = NULL ;
6565 PyObject *swig_obj[2] ;
6566
6567 (void)self;
6568 if (!SWIG_Python_UnpackTuple(args, "plfill", 2, 2, swig_obj)) SWIG_fail;
6569 {
6570 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6571 if ( tmp1 == NULL )
6572 return NULL;
6573 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6574 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6575 }
6576 {
6577 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6578 if ( tmp3 == NULL )
6579 return NULL;
6580 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6581 {
6582 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6583 return NULL;
6584 }
6585 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6586 }
6587 plfill(arg1,(double const *)arg2,(double const *)arg3);
6588 resultobj = SWIG_Py_Void();
6589 {
6590 Py_CLEAR( tmp1 );
6591 }
6592 {
6593 Py_CLEAR( tmp3 );
6594 }
6595 return resultobj;
6596fail:
6597 {
6598 Py_CLEAR( tmp1 );
6599 }
6600 {
6601 Py_CLEAR( tmp3 );
6602 }
6603 return NULL;
6604}
6605
6606
6607SWIGINTERN PyObject *_wrap_plfill3(PyObject *self, PyObject *args) {
6608 PyObject *resultobj = 0;
6609 PLINT arg1 ;
6610 PLFLT *arg2 = 0 ;
6611 PLFLT *arg3 = 0 ;
6612 PLFLT *arg4 = 0 ;
6613 PyArrayObject *tmp1 = NULL ;
6614 PyArrayObject *tmp3 = NULL ;
6615 PyArrayObject *tmp4 = NULL ;
6616 PyObject *swig_obj[3] ;
6617
6618 (void)self;
6619 if (!SWIG_Python_UnpackTuple(args, "plfill3", 3, 3, swig_obj)) SWIG_fail;
6620 {
6621 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6622 if ( tmp1 == NULL )
6623 return NULL;
6624 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6625 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6626 }
6627 {
6628 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6629 if ( tmp3 == NULL )
6630 return NULL;
6631 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6632 {
6633 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6634 return NULL;
6635 }
6636 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6637 }
6638 {
6639 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6640 if ( tmp4 == NULL )
6641 return NULL;
6642 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6643 {
6644 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6645 return NULL;
6646 }
6647 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6648 }
6649 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6650 resultobj = SWIG_Py_Void();
6651 {
6652 Py_CLEAR( tmp1 );
6653 }
6654 {
6655 Py_CLEAR( tmp3 );
6656 }
6657 {
6658 Py_CLEAR( tmp4 );
6659 }
6660 return resultobj;
6661fail:
6662 {
6663 Py_CLEAR( tmp1 );
6664 }
6665 {
6666 Py_CLEAR( tmp3 );
6667 }
6668 {
6669 Py_CLEAR( tmp4 );
6670 }
6671 return NULL;
6672}
6673
6674
6675SWIGINTERN PyObject *_wrap_plgradient(PyObject *self, PyObject *args) {
6676 PyObject *resultobj = 0;
6677 PLINT arg1 ;
6678 PLFLT *arg2 = 0 ;
6679 PLFLT *arg3 = 0 ;
6680 PLFLT arg4 ;
6681 PyArrayObject *tmp1 = NULL ;
6682 PyArrayObject *tmp3 = NULL ;
6683 double val4 ;
6684 int ecode4 = 0 ;
6685 PyObject *swig_obj[3] ;
6686
6687 (void)self;
6688 if (!SWIG_Python_UnpackTuple(args, "plgradient", 3, 3, swig_obj)) SWIG_fail;
6689 {
6690 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6691 if ( tmp1 == NULL )
6692 return NULL;
6693 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6694 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6695 }
6696 {
6697 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6698 if ( tmp3 == NULL )
6699 return NULL;
6700 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6701 {
6702 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6703 return NULL;
6704 }
6705 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6706 }
6707 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
6708 if (!SWIG_IsOK(ecode4)) {
6709 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6710 }
6711 arg4 = (PLFLT)(val4);
6712 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6713 resultobj = SWIG_Py_Void();
6714 {
6715 Py_CLEAR( tmp1 );
6716 }
6717 {
6718 Py_CLEAR( tmp3 );
6719 }
6720 return resultobj;
6721fail:
6722 {
6723 Py_CLEAR( tmp1 );
6724 }
6725 {
6726 Py_CLEAR( tmp3 );
6727 }
6728 return NULL;
6729}
6730
6731
6732SWIGINTERN PyObject *_wrap_plflush(PyObject *self, PyObject *args) {
6733 PyObject *resultobj = 0;
6734
6735 (void)self;
6736 if (!SWIG_Python_UnpackTuple(args, "plflush", 0, 0, 0)) SWIG_fail;
6737 plflush();
6738 resultobj = SWIG_Py_Void();
6739 return resultobj;
6740fail:
6741 return NULL;
6742}
6743
6744
6745SWIGINTERN PyObject *_wrap_plfont(PyObject *self, PyObject *args) {
6746 PyObject *resultobj = 0;
6747 PLINT arg1 ;
6748 int val1 ;
6749 int ecode1 = 0 ;
6750 PyObject *swig_obj[1] ;
6751
6752 (void)self;
6753 if (!args) SWIG_fail;
6754 swig_obj[0] = args;
6755 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6756 if (!SWIG_IsOK(ecode1)) {
6757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6758 }
6759 arg1 = (PLINT)(val1);
6760 plfont(arg1);
6761 resultobj = SWIG_Py_Void();
6762 return resultobj;
6763fail:
6764 return NULL;
6765}
6766
6767
6768SWIGINTERN PyObject *_wrap_plfontld(PyObject *self, PyObject *args) {
6769 PyObject *resultobj = 0;
6770 PLINT arg1 ;
6771 int val1 ;
6772 int ecode1 = 0 ;
6773 PyObject *swig_obj[1] ;
6774
6775 (void)self;
6776 if (!args) SWIG_fail;
6777 swig_obj[0] = args;
6778 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6779 if (!SWIG_IsOK(ecode1)) {
6780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6781 }
6782 arg1 = (PLINT)(val1);
6783 plfontld(arg1);
6784 resultobj = SWIG_Py_Void();
6785 return resultobj;
6786fail:
6787 return NULL;
6788}
6789
6790
6791SWIGINTERN PyObject *_wrap_plgchr(PyObject *self, PyObject *args) {
6792 PyObject *resultobj = 0;
6793 PLFLT *arg1 = 0 ;
6794 PLFLT *arg2 = 0 ;
6795 PLFLT temp1 ;
6796 int res1 = SWIG_TMPOBJ ;
6797 PLFLT temp2 ;
6798 int res2 = SWIG_TMPOBJ ;
6799
6800 arg1 = &temp1;
6801 arg2 = &temp2;
6802 (void)self;
6803 if (!SWIG_Python_UnpackTuple(args, "plgchr", 0, 0, 0)) SWIG_fail;
6804 plgchr(arg1,arg2);
6805 resultobj = SWIG_Py_Void();
6806 if (SWIG_IsTmpObj(res1)) {
6807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
6808 } else {
6809 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
6811 }
6812 if (SWIG_IsTmpObj(res2)) {
6813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
6814 } else {
6815 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
6817 }
6818 return resultobj;
6819fail:
6820 return NULL;
6821}
6822
6823
6824SWIGINTERN PyObject *_wrap_plgcol0(PyObject *self, PyObject *args) {
6825 PyObject *resultobj = 0;
6826 PLINT arg1 ;
6827 PLINT *arg2 = 0 ;
6828 PLINT *arg3 = 0 ;
6829 PLINT *arg4 = 0 ;
6830 int val1 ;
6831 int ecode1 = 0 ;
6832 PLINT temp2 ;
6833 int res2 = SWIG_TMPOBJ ;
6834 PLINT temp3 ;
6835 int res3 = SWIG_TMPOBJ ;
6836 PLINT temp4 ;
6837 int res4 = SWIG_TMPOBJ ;
6838 PyObject *swig_obj[1] ;
6839
6840 arg2 = &temp2;
6841 arg3 = &temp3;
6842 arg4 = &temp4;
6843 (void)self;
6844 if (!args) SWIG_fail;
6845 swig_obj[0] = args;
6846 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6847 if (!SWIG_IsOK(ecode1)) {
6848 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6849 }
6850 arg1 = (PLINT)(val1);
6851 plgcol0(arg1,arg2,arg3,arg4);
6852 resultobj = SWIG_Py_Void();
6853 if (SWIG_IsTmpObj(res2)) {
6854 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
6855 } else {
6856 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6857 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
6858 }
6859 if (SWIG_IsTmpObj(res3)) {
6860 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
6861 } else {
6862 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6863 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
6864 }
6865 if (SWIG_IsTmpObj(res4)) {
6866 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
6867 } else {
6868 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6869 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
6870 }
6871 return resultobj;
6872fail:
6873 return NULL;
6874}
6875
6876
6877SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *self, PyObject *args) {
6878 PyObject *resultobj = 0;
6879 PLINT arg1 ;
6880 PLINT *arg2 = 0 ;
6881 PLINT *arg3 = 0 ;
6882 PLINT *arg4 = 0 ;
6883 PLFLT *arg5 = 0 ;
6884 int val1 ;
6885 int ecode1 = 0 ;
6886 PLINT temp2 ;
6887 int res2 = SWIG_TMPOBJ ;
6888 PLINT temp3 ;
6889 int res3 = SWIG_TMPOBJ ;
6890 PLINT temp4 ;
6891 int res4 = SWIG_TMPOBJ ;
6892 PLFLT temp5 ;
6893 int res5 = SWIG_TMPOBJ ;
6894 PyObject *swig_obj[1] ;
6895
6896 arg2 = &temp2;
6897 arg3 = &temp3;
6898 arg4 = &temp4;
6899 arg5 = &temp5;
6900 (void)self;
6901 if (!args) SWIG_fail;
6902 swig_obj[0] = args;
6903 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6904 if (!SWIG_IsOK(ecode1)) {
6905 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6906 }
6907 arg1 = (PLINT)(val1);
6908 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6909 resultobj = SWIG_Py_Void();
6910 if (SWIG_IsTmpObj(res2)) {
6911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
6912 } else {
6913 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6914 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
6915 }
6916 if (SWIG_IsTmpObj(res3)) {
6917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
6918 } else {
6919 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6920 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
6921 }
6922 if (SWIG_IsTmpObj(res4)) {
6923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
6924 } else {
6925 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
6927 }
6928 if (SWIG_IsTmpObj(res5)) {
6929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
6930 } else {
6931 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
6933 }
6934 return resultobj;
6935fail:
6936 return NULL;
6937}
6938
6939
6940SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *self, PyObject *args) {
6941 PyObject *resultobj = 0;
6942 PLINT *arg1 = 0 ;
6943 PLINT *arg2 = 0 ;
6944 PLINT *arg3 = 0 ;
6945 PLINT temp1 ;
6946 int res1 = SWIG_TMPOBJ ;
6947 PLINT temp2 ;
6948 int res2 = SWIG_TMPOBJ ;
6949 PLINT temp3 ;
6950 int res3 = SWIG_TMPOBJ ;
6951
6952 arg1 = &temp1;
6953 arg2 = &temp2;
6954 arg3 = &temp3;
6955 (void)self;
6956 if (!SWIG_Python_UnpackTuple(args, "plgcolbg", 0, 0, 0)) SWIG_fail;
6957 plgcolbg(arg1,arg2,arg3);
6958 resultobj = SWIG_Py_Void();
6959 if (SWIG_IsTmpObj(res1)) {
6960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
6961 } else {
6962 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
6964 }
6965 if (SWIG_IsTmpObj(res2)) {
6966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
6967 } else {
6968 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
6970 }
6971 if (SWIG_IsTmpObj(res3)) {
6972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
6973 } else {
6974 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
6976 }
6977 return resultobj;
6978fail:
6979 return NULL;
6980}
6981
6982
6983SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *self, PyObject *args) {
6984 PyObject *resultobj = 0;
6985 PLINT *arg1 = 0 ;
6986 PLINT *arg2 = 0 ;
6987 PLINT *arg3 = 0 ;
6988 PLFLT *arg4 = 0 ;
6989 PLINT temp1 ;
6990 int res1 = SWIG_TMPOBJ ;
6991 PLINT temp2 ;
6992 int res2 = SWIG_TMPOBJ ;
6993 PLINT temp3 ;
6994 int res3 = SWIG_TMPOBJ ;
6995 PLFLT temp4 ;
6996 int res4 = SWIG_TMPOBJ ;
6997
6998 arg1 = &temp1;
6999 arg2 = &temp2;
7000 arg3 = &temp3;
7001 arg4 = &temp4;
7002 (void)self;
7003 if (!SWIG_Python_UnpackTuple(args, "plgcolbga", 0, 0, 0)) SWIG_fail;
7004 plgcolbga(arg1,arg2,arg3,arg4);
7005 resultobj = SWIG_Py_Void();
7006 if (SWIG_IsTmpObj(res1)) {
7007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7008 } else {
7009 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7011 }
7012 if (SWIG_IsTmpObj(res2)) {
7013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7014 } else {
7015 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7016 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7017 }
7018 if (SWIG_IsTmpObj(res3)) {
7019 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7020 } else {
7021 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7022 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7023 }
7024 if (SWIG_IsTmpObj(res4)) {
7025 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7026 } else {
7027 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7028 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7029 }
7030 return resultobj;
7031fail:
7032 return NULL;
7033}
7034
7035
7036SWIGINTERN PyObject *_wrap_plgcompression(PyObject *self, PyObject *args) {
7037 PyObject *resultobj = 0;
7038 PLINT *arg1 = 0 ;
7039 PLINT temp1 ;
7040 int res1 = SWIG_TMPOBJ ;
7041
7042 arg1 = &temp1;
7043 (void)self;
7044 if (!SWIG_Python_UnpackTuple(args, "plgcompression", 0, 0, 0)) SWIG_fail;
7045 plgcompression(arg1);
7046 resultobj = SWIG_Py_Void();
7047 if (SWIG_IsTmpObj(res1)) {
7048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7049 } else {
7050 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7052 }
7053 return resultobj;
7054fail:
7055 return NULL;
7056}
7057
7058
7059SWIGINTERN PyObject *_wrap_plgdev(PyObject *self, PyObject *args) {
7060 PyObject *resultobj = 0;
7061 char *arg1 = 0 ;
7062 char buff1[1000] ;
7063
7064 {
7065 arg1 = buff1;
7066 }
7067 (void)self;
7068 if (!SWIG_Python_UnpackTuple(args, "plgdev", 0, 0, 0)) SWIG_fail;
7069 plgdev(arg1);
7070 resultobj = SWIG_Py_Void();
7071 {
7072 PyObject *o = PyString_FromString( arg1 );
7073 resultobj = SWIG_Python_AppendOutput(resultobj, o, 1);
7074 }
7075 return resultobj;
7076fail:
7077 return NULL;
7078}
7079
7080
7081SWIGINTERN PyObject *_wrap_plgdidev(PyObject *self, PyObject *args) {
7082 PyObject *resultobj = 0;
7083 PLFLT *arg1 = 0 ;
7084 PLFLT *arg2 = 0 ;
7085 PLFLT *arg3 = 0 ;
7086 PLFLT *arg4 = 0 ;
7087 PLFLT temp1 ;
7088 int res1 = SWIG_TMPOBJ ;
7089 PLFLT temp2 ;
7090 int res2 = SWIG_TMPOBJ ;
7091 PLFLT temp3 ;
7092 int res3 = SWIG_TMPOBJ ;
7093 PLFLT temp4 ;
7094 int res4 = SWIG_TMPOBJ ;
7095
7096 arg1 = &temp1;
7097 arg2 = &temp2;
7098 arg3 = &temp3;
7099 arg4 = &temp4;
7100 (void)self;
7101 if (!SWIG_Python_UnpackTuple(args, "plgdidev", 0, 0, 0)) SWIG_fail;
7102 plgdidev(arg1,arg2,arg3,arg4);
7103 resultobj = SWIG_Py_Void();
7104 if (SWIG_IsTmpObj(res1)) {
7105 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7106 } else {
7107 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7108 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7109 }
7110 if (SWIG_IsTmpObj(res2)) {
7111 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7112 } else {
7113 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7115 }
7116 if (SWIG_IsTmpObj(res3)) {
7117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7118 } else {
7119 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7121 }
7122 if (SWIG_IsTmpObj(res4)) {
7123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7124 } else {
7125 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7126 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7127 }
7128 return resultobj;
7129fail:
7130 return NULL;
7131}
7132
7133
7134SWIGINTERN PyObject *_wrap_plgdiori(PyObject *self, PyObject *args) {
7135 PyObject *resultobj = 0;
7136 PLFLT *arg1 = 0 ;
7137 PLFLT temp1 ;
7138 int res1 = SWIG_TMPOBJ ;
7139
7140 arg1 = &temp1;
7141 (void)self;
7142 if (!SWIG_Python_UnpackTuple(args, "plgdiori", 0, 0, 0)) SWIG_fail;
7143 plgdiori(arg1);
7144 resultobj = SWIG_Py_Void();
7145 if (SWIG_IsTmpObj(res1)) {
7146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7147 } else {
7148 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7149 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7150 }
7151 return resultobj;
7152fail:
7153 return NULL;
7154}
7155
7156
7157SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *self, PyObject *args) {
7158 PyObject *resultobj = 0;
7159 PLFLT *arg1 = 0 ;
7160 PLFLT *arg2 = 0 ;
7161 PLFLT *arg3 = 0 ;
7162 PLFLT *arg4 = 0 ;
7163 PLFLT temp1 ;
7164 int res1 = SWIG_TMPOBJ ;
7165 PLFLT temp2 ;
7166 int res2 = SWIG_TMPOBJ ;
7167 PLFLT temp3 ;
7168 int res3 = SWIG_TMPOBJ ;
7169 PLFLT temp4 ;
7170 int res4 = SWIG_TMPOBJ ;
7171
7172 arg1 = &temp1;
7173 arg2 = &temp2;
7174 arg3 = &temp3;
7175 arg4 = &temp4;
7176 (void)self;
7177 if (!SWIG_Python_UnpackTuple(args, "plgdiplt", 0, 0, 0)) SWIG_fail;
7178 plgdiplt(arg1,arg2,arg3,arg4);
7179 resultobj = SWIG_Py_Void();
7180 if (SWIG_IsTmpObj(res1)) {
7181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7182 } else {
7183 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7184 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7185 }
7186 if (SWIG_IsTmpObj(res2)) {
7187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7188 } else {
7189 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7191 }
7192 if (SWIG_IsTmpObj(res3)) {
7193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7194 } else {
7195 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7197 }
7198 if (SWIG_IsTmpObj(res4)) {
7199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7200 } else {
7201 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7203 }
7204 return resultobj;
7205fail:
7206 return NULL;
7207}
7208
7209
7210SWIGINTERN PyObject *_wrap_plgfam(PyObject *self, PyObject *args) {
7211 PyObject *resultobj = 0;
7212 PLINT *arg1 = 0 ;
7213 PLINT *arg2 = 0 ;
7214 PLINT *arg3 = 0 ;
7215 PLINT temp1 ;
7216 int res1 = SWIG_TMPOBJ ;
7217 PLINT temp2 ;
7218 int res2 = SWIG_TMPOBJ ;
7219 PLINT temp3 ;
7220 int res3 = SWIG_TMPOBJ ;
7221
7222 arg1 = &temp1;
7223 arg2 = &temp2;
7224 arg3 = &temp3;
7225 (void)self;
7226 if (!SWIG_Python_UnpackTuple(args, "plgfam", 0, 0, 0)) SWIG_fail;
7227 plgfam(arg1,arg2,arg3);
7228 resultobj = SWIG_Py_Void();
7229 if (SWIG_IsTmpObj(res1)) {
7230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7231 } else {
7232 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7234 }
7235 if (SWIG_IsTmpObj(res2)) {
7236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7237 } else {
7238 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7240 }
7241 if (SWIG_IsTmpObj(res3)) {
7242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7243 } else {
7244 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7245 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7246 }
7247 return resultobj;
7248fail:
7249 return NULL;
7250}
7251
7252
7253SWIGINTERN PyObject *_wrap_plgfci(PyObject *self, PyObject *args) {
7254 PyObject *resultobj = 0;
7255 PLUNICODE *arg1 = 0 ;
7256 PLUNICODE temp1 ;
7257 int res1 = SWIG_TMPOBJ ;
7258
7259 arg1 = &temp1;
7260 (void)self;
7261 if (!SWIG_Python_UnpackTuple(args, "plgfci", 0, 0, 0)) SWIG_fail;
7262 plgfci(arg1);
7263 resultobj = SWIG_Py_Void();
7264 if (SWIG_IsTmpObj(res1)) {
7265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)), 1);
7266 } else {
7267 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags), 1);
7269 }
7270 return resultobj;
7271fail:
7272 return NULL;
7273}
7274
7275
7276SWIGINTERN PyObject *_wrap_plgfnam(PyObject *self, PyObject *args) {
7277 PyObject *resultobj = 0;
7278 char *arg1 = 0 ;
7279 char buff1[1000] ;
7280
7281 {
7282 arg1 = buff1;
7283 }
7284 (void)self;
7285 if (!SWIG_Python_UnpackTuple(args, "plgfnam", 0, 0, 0)) SWIG_fail;
7286 plgfnam(arg1);
7287 resultobj = SWIG_Py_Void();
7288 {
7289 PyObject *o = PyString_FromString( arg1 );
7290 resultobj = SWIG_Python_AppendOutput(resultobj, o, 1);
7291 }
7292 return resultobj;
7293fail:
7294 return NULL;
7295}
7296
7297
7298SWIGINTERN PyObject *_wrap_plgfont(PyObject *self, PyObject *args) {
7299 PyObject *resultobj = 0;
7300 PLINT *arg1 = 0 ;
7301 PLINT *arg2 = 0 ;
7302 PLINT *arg3 = 0 ;
7303 PLINT temp1 ;
7304 int res1 = SWIG_TMPOBJ ;
7305 PLINT temp2 ;
7306 int res2 = SWIG_TMPOBJ ;
7307 PLINT temp3 ;
7308 int res3 = SWIG_TMPOBJ ;
7309
7310 arg1 = &temp1;
7311 arg2 = &temp2;
7312 arg3 = &temp3;
7313 (void)self;
7314 if (!SWIG_Python_UnpackTuple(args, "plgfont", 0, 0, 0)) SWIG_fail;
7315 plgfont(arg1,arg2,arg3);
7316 resultobj = SWIG_Py_Void();
7317 if (SWIG_IsTmpObj(res1)) {
7318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7319 } else {
7320 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7322 }
7323 if (SWIG_IsTmpObj(res2)) {
7324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7325 } else {
7326 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7328 }
7329 if (SWIG_IsTmpObj(res3)) {
7330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7331 } else {
7332 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7334 }
7335 return resultobj;
7336fail:
7337 return NULL;
7338}
7339
7340
7341SWIGINTERN PyObject *_wrap_plglevel(PyObject *self, PyObject *args) {
7342 PyObject *resultobj = 0;
7343 PLINT *arg1 = 0 ;
7344 PLINT temp1 ;
7345 int res1 = SWIG_TMPOBJ ;
7346
7347 arg1 = &temp1;
7348 (void)self;
7349 if (!SWIG_Python_UnpackTuple(args, "plglevel", 0, 0, 0)) SWIG_fail;
7350 plglevel(arg1);
7351 resultobj = SWIG_Py_Void();
7352 if (SWIG_IsTmpObj(res1)) {
7353 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7354 } else {
7355 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7356 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7357 }
7358 return resultobj;
7359fail:
7360 return NULL;
7361}
7362
7363
7364SWIGINTERN PyObject *_wrap_plgpage(PyObject *self, PyObject *args) {
7365 PyObject *resultobj = 0;
7366 PLFLT *arg1 = 0 ;
7367 PLFLT *arg2 = 0 ;
7368 PLINT *arg3 = 0 ;
7369 PLINT *arg4 = 0 ;
7370 PLINT *arg5 = 0 ;
7371 PLINT *arg6 = 0 ;
7372 PLFLT temp1 ;
7373 int res1 = SWIG_TMPOBJ ;
7374 PLFLT temp2 ;
7375 int res2 = SWIG_TMPOBJ ;
7376 PLINT temp3 ;
7377 int res3 = SWIG_TMPOBJ ;
7378 PLINT temp4 ;
7379 int res4 = SWIG_TMPOBJ ;
7380 PLINT temp5 ;
7381 int res5 = SWIG_TMPOBJ ;
7382 PLINT temp6 ;
7383 int res6 = SWIG_TMPOBJ ;
7384
7385 arg1 = &temp1;
7386 arg2 = &temp2;
7387 arg3 = &temp3;
7388 arg4 = &temp4;
7389 arg5 = &temp5;
7390 arg6 = &temp6;
7391 (void)self;
7392 if (!SWIG_Python_UnpackTuple(args, "plgpage", 0, 0, 0)) SWIG_fail;
7393 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7394 resultobj = SWIG_Py_Void();
7395 if (SWIG_IsTmpObj(res1)) {
7396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7397 } else {
7398 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7400 }
7401 if (SWIG_IsTmpObj(res2)) {
7402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7403 } else {
7404 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7406 }
7407 if (SWIG_IsTmpObj(res3)) {
7408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7409 } else {
7410 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7411 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7412 }
7413 if (SWIG_IsTmpObj(res4)) {
7414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
7415 } else {
7416 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
7418 }
7419 if (SWIG_IsTmpObj(res5)) {
7420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
7421 } else {
7422 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
7424 }
7425 if (SWIG_IsTmpObj(res6)) {
7426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)), 1);
7427 } else {
7428 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags), 1);
7430 }
7431 return resultobj;
7432fail:
7433 return NULL;
7434}
7435
7436
7437SWIGINTERN PyObject *_wrap_plgra(PyObject *self, PyObject *args) {
7438 PyObject *resultobj = 0;
7439
7440 (void)self;
7441 if (!SWIG_Python_UnpackTuple(args, "plgra", 0, 0, 0)) SWIG_fail;
7442 plgra();
7443 resultobj = SWIG_Py_Void();
7444 return resultobj;
7445fail:
7446 return NULL;
7447}
7448
7449
7450SWIGINTERN PyObject *_wrap_plgriddata(PyObject *self, PyObject *args) {
7451 PyObject *resultobj = 0;
7452 PLFLT *arg1 = 0 ;
7453 PLFLT *arg2 = 0 ;
7454 PLFLT *arg3 = 0 ;
7455 PLINT arg4 ;
7456 PLFLT *arg5 = 0 ;
7457 PLINT arg6 ;
7458 PLFLT *arg7 = 0 ;
7459 PLINT arg8 ;
7460 PLFLT **arg9 = 0 ;
7461 PLINT arg10 ;
7462 PLFLT arg11 ;
7463 PyArrayObject *tmp1 = NULL ;
7464 PyArrayObject *tmp2 = NULL ;
7465 PyArrayObject *tmp3 = NULL ;
7466 PyArrayObject *tmp5 = NULL ;
7467 PyArrayObject *tmp7 = NULL ;
7468 PyObject *array7 = NULL ;
7469 int val10 ;
7470 int ecode10 = 0 ;
7471 double val11 ;
7472 int ecode11 = 0 ;
7473 PyObject *swig_obj[7] ;
7474
7475 (void)self;
7476 if (!SWIG_Python_UnpackTuple(args, "plgriddata", 7, 7, swig_obj)) SWIG_fail;
7477 {
7478 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7479 if ( tmp1 == NULL )
7480 return NULL;
7481 Alen = PyArray_DIMS( tmp1 )[0];
7482 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7483 }
7484 {
7485 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
7486 if ( tmp2 == NULL )
7487 return NULL;
7488 if ( PyArray_DIMS( tmp2 )[0] != Alen )
7489 {
7490 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7491 return NULL;
7492 }
7493 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7494 }
7495 {
7496 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
7497 if ( tmp3 == NULL )
7498 return NULL;
7499 if ( PyArray_DIMS( tmp3 )[0] != Alen )
7500 {
7501 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7502 return NULL;
7503 }
7504 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7505 arg4 = PyArray_DIMS( tmp3 )[0];
7506 }
7507 {
7508 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
7509 if ( tmp5 == NULL )
7510 return NULL;
7511 Xlen = PyArray_DIMS( tmp5 )[0];
7512 arg6 = Xlen;
7513 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7514 }
7515 {
7516 int i, size;
7517 npy_intp dims[2];
7518 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
7519 if ( tmp7 == NULL )
7520 return NULL;
7521 Ylen = PyArray_DIMS( tmp7 )[0];
7522 arg8 = Ylen;
7523 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7524 // Make created 2D array7 have dimensions from prior ArrayX in the argument
7525 // list and this ArrayY.
7526 dims[0] = Xlen;
7527 dims[1] = Ylen;
7528 array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
7529 if ( !array7 )
7530 return NULL;
7531 size = Ylen;
7532 arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
7533 for ( i = 0; i < Xlen; i++ )
7534 arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7535 }
7536 ecode10 = SWIG_AsVal_int(swig_obj[5], &val10);
7537 if (!SWIG_IsOK(ecode10)) {
7538 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7539 }
7540 arg10 = (PLINT)(val10);
7541 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
7542 if (!SWIG_IsOK(ecode11)) {
7543 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7544 }
7545 arg11 = (PLFLT)(val11);
7546 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7547 resultobj = SWIG_Py_Void();
7548 {
7549 resultobj = SWIG_Python_AppendOutput(resultobj, array7, 1);
7550 }
7551 {
7552 Py_CLEAR( tmp1 );
7553 }
7554 {
7555 Py_CLEAR( tmp2 );
7556 }
7557 {
7558 Py_CLEAR( tmp3 );
7559 }
7560 {
7561 Py_CLEAR( tmp5 );
7562 }
7563 {
7564 Py_CLEAR( tmp7 );
7565 free( arg9 );
7566 }
7567 return resultobj;
7568fail:
7569 {
7570 Py_CLEAR( tmp1 );
7571 }
7572 {
7573 Py_CLEAR( tmp2 );
7574 }
7575 {
7576 Py_CLEAR( tmp3 );
7577 }
7578 {
7579 Py_CLEAR( tmp5 );
7580 }
7581 {
7582 Py_CLEAR( tmp7 );
7583 free( arg9 );
7584 }
7585 return NULL;
7586}
7587
7588
7589SWIGINTERN PyObject *_wrap_plgspa(PyObject *self, PyObject *args) {
7590 PyObject *resultobj = 0;
7591 PLFLT *arg1 = 0 ;
7592 PLFLT *arg2 = 0 ;
7593 PLFLT *arg3 = 0 ;
7594 PLFLT *arg4 = 0 ;
7595 PLFLT temp1 ;
7596 int res1 = SWIG_TMPOBJ ;
7597 PLFLT temp2 ;
7598 int res2 = SWIG_TMPOBJ ;
7599 PLFLT temp3 ;
7600 int res3 = SWIG_TMPOBJ ;
7601 PLFLT temp4 ;
7602 int res4 = SWIG_TMPOBJ ;
7603
7604 arg1 = &temp1;
7605 arg2 = &temp2;
7606 arg3 = &temp3;
7607 arg4 = &temp4;
7608 (void)self;
7609 if (!SWIG_Python_UnpackTuple(args, "plgspa", 0, 0, 0)) SWIG_fail;
7610 plgspa(arg1,arg2,arg3,arg4);
7611 resultobj = SWIG_Py_Void();
7612 if (SWIG_IsTmpObj(res1)) {
7613 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7614 } else {
7615 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7617 }
7618 if (SWIG_IsTmpObj(res2)) {
7619 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7620 } else {
7621 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7623 }
7624 if (SWIG_IsTmpObj(res3)) {
7625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7626 } else {
7627 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7629 }
7630 if (SWIG_IsTmpObj(res4)) {
7631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7632 } else {
7633 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7635 }
7636 return resultobj;
7637fail:
7638 return NULL;
7639}
7640
7641
7642SWIGINTERN PyObject *_wrap_plgstrm(PyObject *self, PyObject *args) {
7643 PyObject *resultobj = 0;
7644 PLINT *arg1 = 0 ;
7645 PLINT temp1 ;
7646 int res1 = SWIG_TMPOBJ ;
7647
7648 arg1 = &temp1;
7649 (void)self;
7650 if (!SWIG_Python_UnpackTuple(args, "plgstrm", 0, 0, 0)) SWIG_fail;
7651 plgstrm(arg1);
7652 resultobj = SWIG_Py_Void();
7653 if (SWIG_IsTmpObj(res1)) {
7654 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7655 } else {
7656 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7657 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7658 }
7659 return resultobj;
7660fail:
7661 return NULL;
7662}
7663
7664
7665SWIGINTERN PyObject *_wrap_plgver(PyObject *self, PyObject *args) {
7666 PyObject *resultobj = 0;
7667 char *arg1 = 0 ;
7668 char buff1[1000] ;
7669
7670 {
7671 arg1 = buff1;
7672 }
7673 (void)self;
7674 if (!SWIG_Python_UnpackTuple(args, "plgver", 0, 0, 0)) SWIG_fail;
7675 plgver(arg1);
7676 resultobj = SWIG_Py_Void();
7677 {
7678 PyObject *o = PyString_FromString( arg1 );
7679 resultobj = SWIG_Python_AppendOutput(resultobj, o, 1);
7680 }
7681 return resultobj;
7682fail:
7683 return NULL;
7684}
7685
7686
7687SWIGINTERN PyObject *_wrap_plgvpd(PyObject *self, PyObject *args) {
7688 PyObject *resultobj = 0;
7689 PLFLT *arg1 = 0 ;
7690 PLFLT *arg2 = 0 ;
7691 PLFLT *arg3 = 0 ;
7692 PLFLT *arg4 = 0 ;
7693 PLFLT temp1 ;
7694 int res1 = SWIG_TMPOBJ ;
7695 PLFLT temp2 ;
7696 int res2 = SWIG_TMPOBJ ;
7697 PLFLT temp3 ;
7698 int res3 = SWIG_TMPOBJ ;
7699 PLFLT temp4 ;
7700 int res4 = SWIG_TMPOBJ ;
7701
7702 arg1 = &temp1;
7703 arg2 = &temp2;
7704 arg3 = &temp3;
7705 arg4 = &temp4;
7706 (void)self;
7707 if (!SWIG_Python_UnpackTuple(args, "plgvpd", 0, 0, 0)) SWIG_fail;
7708 plgvpd(arg1,arg2,arg3,arg4);
7709 resultobj = SWIG_Py_Void();
7710 if (SWIG_IsTmpObj(res1)) {
7711 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7712 } else {
7713 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7714 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7715 }
7716 if (SWIG_IsTmpObj(res2)) {
7717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7718 } else {
7719 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7720 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7721 }
7722 if (SWIG_IsTmpObj(res3)) {
7723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7724 } else {
7725 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7726 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7727 }
7728 if (SWIG_IsTmpObj(res4)) {
7729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7730 } else {
7731 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7733 }
7734 return resultobj;
7735fail:
7736 return NULL;
7737}
7738
7739
7740SWIGINTERN PyObject *_wrap_plgvpw(PyObject *self, PyObject *args) {
7741 PyObject *resultobj = 0;
7742 PLFLT *arg1 = 0 ;
7743 PLFLT *arg2 = 0 ;
7744 PLFLT *arg3 = 0 ;
7745 PLFLT *arg4 = 0 ;
7746 PLFLT temp1 ;
7747 int res1 = SWIG_TMPOBJ ;
7748 PLFLT temp2 ;
7749 int res2 = SWIG_TMPOBJ ;
7750 PLFLT temp3 ;
7751 int res3 = SWIG_TMPOBJ ;
7752 PLFLT temp4 ;
7753 int res4 = SWIG_TMPOBJ ;
7754
7755 arg1 = &temp1;
7756 arg2 = &temp2;
7757 arg3 = &temp3;
7758 arg4 = &temp4;
7759 (void)self;
7760 if (!SWIG_Python_UnpackTuple(args, "plgvpw", 0, 0, 0)) SWIG_fail;
7761 plgvpw(arg1,arg2,arg3,arg4);
7762 resultobj = SWIG_Py_Void();
7763 if (SWIG_IsTmpObj(res1)) {
7764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
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_double, new_flags), 1);
7768 }
7769 if (SWIG_IsTmpObj(res2)) {
7770 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
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_double, new_flags), 1);
7774 }
7775 if (SWIG_IsTmpObj(res3)) {
7776 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7777 } else {
7778 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7779 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7780 }
7781 if (SWIG_IsTmpObj(res4)) {
7782 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7783 } else {
7784 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7785 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7786 }
7787 return resultobj;
7788fail:
7789 return NULL;
7790}
7791
7792
7793SWIGINTERN PyObject *_wrap_plgxax(PyObject *self, PyObject *args) {
7794 PyObject *resultobj = 0;
7795 PLINT *arg1 = 0 ;
7796 PLINT *arg2 = 0 ;
7797 PLINT temp1 ;
7798 int res1 = SWIG_TMPOBJ ;
7799 PLINT temp2 ;
7800 int res2 = SWIG_TMPOBJ ;
7801
7802 arg1 = &temp1;
7803 arg2 = &temp2;
7804 (void)self;
7805 if (!SWIG_Python_UnpackTuple(args, "plgxax", 0, 0, 0)) SWIG_fail;
7806 plgxax(arg1,arg2);
7807 resultobj = SWIG_Py_Void();
7808 if (SWIG_IsTmpObj(res1)) {
7809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7810 } else {
7811 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7813 }
7814 if (SWIG_IsTmpObj(res2)) {
7815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7816 } else {
7817 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7819 }
7820 return resultobj;
7821fail:
7822 return NULL;
7823}
7824
7825
7826SWIGINTERN PyObject *_wrap_plgyax(PyObject *self, PyObject *args) {
7827 PyObject *resultobj = 0;
7828 PLINT *arg1 = 0 ;
7829 PLINT *arg2 = 0 ;
7830 PLINT temp1 ;
7831 int res1 = SWIG_TMPOBJ ;
7832 PLINT temp2 ;
7833 int res2 = SWIG_TMPOBJ ;
7834
7835 arg1 = &temp1;
7836 arg2 = &temp2;
7837 (void)self;
7838 if (!SWIG_Python_UnpackTuple(args, "plgyax", 0, 0, 0)) SWIG_fail;
7839 plgyax(arg1,arg2);
7840 resultobj = SWIG_Py_Void();
7841 if (SWIG_IsTmpObj(res1)) {
7842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7843 } else {
7844 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7846 }
7847 if (SWIG_IsTmpObj(res2)) {
7848 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7849 } else {
7850 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7852 }
7853 return resultobj;
7854fail:
7855 return NULL;
7856}
7857
7858
7859SWIGINTERN PyObject *_wrap_plgzax(PyObject *self, PyObject *args) {
7860 PyObject *resultobj = 0;
7861 PLINT *arg1 = 0 ;
7862 PLINT *arg2 = 0 ;
7863 PLINT temp1 ;
7864 int res1 = SWIG_TMPOBJ ;
7865 PLINT temp2 ;
7866 int res2 = SWIG_TMPOBJ ;
7867
7868 arg1 = &temp1;
7869 arg2 = &temp2;
7870 (void)self;
7871 if (!SWIG_Python_UnpackTuple(args, "plgzax", 0, 0, 0)) SWIG_fail;
7872 plgzax(arg1,arg2);
7873 resultobj = SWIG_Py_Void();
7874 if (SWIG_IsTmpObj(res1)) {
7875 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7876 } else {
7877 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7879 }
7880 if (SWIG_IsTmpObj(res2)) {
7881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7882 } else {
7883 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7885 }
7886 return resultobj;
7887fail:
7888 return NULL;
7889}
7890
7891
7892SWIGINTERN PyObject *_wrap_plhist(PyObject *self, PyObject *args) {
7893 PyObject *resultobj = 0;
7894 PLINT arg1 ;
7895 PLFLT *arg2 = 0 ;
7896 PLFLT arg3 ;
7897 PLFLT arg4 ;
7898 PLINT arg5 ;
7899 PLINT arg6 ;
7900 PyArrayObject *tmp1 = NULL ;
7901 double val3 ;
7902 int ecode3 = 0 ;
7903 double val4 ;
7904 int ecode4 = 0 ;
7905 int val5 ;
7906 int ecode5 = 0 ;
7907 int val6 ;
7908 int ecode6 = 0 ;
7909 PyObject *swig_obj[5] ;
7910
7911 (void)self;
7912 if (!SWIG_Python_UnpackTuple(args, "plhist", 5, 5, swig_obj)) SWIG_fail;
7913 {
7914 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7915 if ( tmp1 == NULL )
7916 return NULL;
7917 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7918 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7919 }
7920 ecode3 = SWIG_AsVal_double(swig_obj[1], &val3);
7921 if (!SWIG_IsOK(ecode3)) {
7922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7923 }
7924 arg3 = (PLFLT)(val3);
7925 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
7926 if (!SWIG_IsOK(ecode4)) {
7927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7928 }
7929 arg4 = (PLFLT)(val4);
7930 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
7931 if (!SWIG_IsOK(ecode5)) {
7932 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7933 }
7934 arg5 = (PLINT)(val5);
7935 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
7936 if (!SWIG_IsOK(ecode6)) {
7937 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7938 }
7939 arg6 = (PLINT)(val6);
7940 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7941 resultobj = SWIG_Py_Void();
7942 {
7943 Py_CLEAR( tmp1 );
7944 }
7945 return resultobj;
7946fail:
7947 {
7948 Py_CLEAR( tmp1 );
7949 }
7950 return NULL;
7951}
7952
7953
7954SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *self, PyObject *args) {
7955 PyObject *resultobj = 0;
7956 PLFLT arg1 ;
7957 PLFLT arg2 ;
7958 PLFLT arg3 ;
7959 PLFLT *arg4 = 0 ;
7960 PLFLT *arg5 = 0 ;
7961 PLFLT *arg6 = 0 ;
7962 double val1 ;
7963 int ecode1 = 0 ;
7964 double val2 ;
7965 int ecode2 = 0 ;
7966 double val3 ;
7967 int ecode3 = 0 ;
7968 PLFLT temp4 ;
7969 int res4 = SWIG_TMPOBJ ;
7970 PLFLT temp5 ;
7971 int res5 = SWIG_TMPOBJ ;
7972 PLFLT temp6 ;
7973 int res6 = SWIG_TMPOBJ ;
7974 PyObject *swig_obj[3] ;
7975
7976 arg4 = &temp4;
7977 arg5 = &temp5;
7978 arg6 = &temp6;
7979 (void)self;
7980 if (!SWIG_Python_UnpackTuple(args, "plhlsrgb", 3, 3, swig_obj)) SWIG_fail;
7981 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7982 if (!SWIG_IsOK(ecode1)) {
7983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7984 }
7985 arg1 = (PLFLT)(val1);
7986 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7987 if (!SWIG_IsOK(ecode2)) {
7988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7989 }
7990 arg2 = (PLFLT)(val2);
7991 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7992 if (!SWIG_IsOK(ecode3)) {
7993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7994 }
7995 arg3 = (PLFLT)(val3);
7996 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7997 resultobj = SWIG_Py_Void();
7998 if (SWIG_IsTmpObj(res4)) {
7999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
8000 } else {
8001 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
8003 }
8004 if (SWIG_IsTmpObj(res5)) {
8005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
8006 } else {
8007 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
8009 }
8010 if (SWIG_IsTmpObj(res6)) {
8011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 1);
8012 } else {
8013 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 1);
8015 }
8016 return resultobj;
8017fail:
8018 return NULL;
8019}
8020
8021
8022SWIGINTERN PyObject *_wrap_plinit(PyObject *self, PyObject *args) {
8023 PyObject *resultobj = 0;
8024
8025 (void)self;
8026 if (!SWIG_Python_UnpackTuple(args, "plinit", 0, 0, 0)) SWIG_fail;
8027 plinit();
8028 resultobj = SWIG_Py_Void();
8029 return resultobj;
8030fail:
8031 return NULL;
8032}
8033
8034
8035SWIGINTERN PyObject *_wrap_pljoin(PyObject *self, PyObject *args) {
8036 PyObject *resultobj = 0;
8037 PLFLT arg1 ;
8038 PLFLT arg2 ;
8039 PLFLT arg3 ;
8040 PLFLT arg4 ;
8041 double val1 ;
8042 int ecode1 = 0 ;
8043 double val2 ;
8044 int ecode2 = 0 ;
8045 double val3 ;
8046 int ecode3 = 0 ;
8047 double val4 ;
8048 int ecode4 = 0 ;
8049 PyObject *swig_obj[4] ;
8050
8051 (void)self;
8052 if (!SWIG_Python_UnpackTuple(args, "pljoin", 4, 4, swig_obj)) SWIG_fail;
8053 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8054 if (!SWIG_IsOK(ecode1)) {
8055 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
8056 }
8057 arg1 = (PLFLT)(val1);
8058 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8059 if (!SWIG_IsOK(ecode2)) {
8060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
8061 }
8062 arg2 = (PLFLT)(val2);
8063 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8064 if (!SWIG_IsOK(ecode3)) {
8065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
8066 }
8067 arg3 = (PLFLT)(val3);
8068 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8069 if (!SWIG_IsOK(ecode4)) {
8070 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
8071 }
8072 arg4 = (PLFLT)(val4);
8073 pljoin(arg1,arg2,arg3,arg4);
8074 resultobj = SWIG_Py_Void();
8075 return resultobj;
8076fail:
8077 return NULL;
8078}
8079
8080
8081SWIGINTERN PyObject *_wrap_pllab(PyObject *self, PyObject *args) {
8082 PyObject *resultobj = 0;
8083 char *arg1 = 0 ;
8084 char *arg2 = 0 ;
8085 char *arg3 = 0 ;
8086 int res1 ;
8087 char *buf1 = 0 ;
8088 int alloc1 = 0 ;
8089 int res2 ;
8090 char *buf2 = 0 ;
8091 int alloc2 = 0 ;
8092 int res3 ;
8093 char *buf3 = 0 ;
8094 int alloc3 = 0 ;
8095 PyObject *swig_obj[3] ;
8096
8097 (void)self;
8098 if (!SWIG_Python_UnpackTuple(args, "pllab", 3, 3, swig_obj)) SWIG_fail;
8099 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8100 if (!SWIG_IsOK(res1)) {
8101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
8102 }
8103 arg1 = (char *)(buf1);
8104 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
8105 if (!SWIG_IsOK(res2)) {
8106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
8107 }
8108 arg2 = (char *)(buf2);
8109 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
8110 if (!SWIG_IsOK(res3)) {
8111 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
8112 }
8113 arg3 = (char *)(buf3);
8114 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
8115 resultobj = SWIG_Py_Void();
8116 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8117 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8118 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8119 return resultobj;
8120fail:
8121 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8122 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8123 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8124 return NULL;
8125}
8126
8127
8128SWIGINTERN PyObject *_wrap_pllegend(PyObject *self, PyObject *args) {
8129 PyObject *resultobj = 0;
8130 PLFLT *arg1 = 0 ;
8131 PLFLT *arg2 = 0 ;
8132 PLINT arg3 ;
8133 PLINT arg4 ;
8134 PLFLT arg5 ;
8135 PLFLT arg6 ;
8136 PLFLT arg7 ;
8137 PLINT arg8 ;
8138 PLINT arg9 ;
8139 PLINT arg10 ;
8140 PLINT arg11 ;
8141 PLINT arg12 ;
8142 PLINT arg13 ;
8143 PLINT *arg14 = 0 ;
8144 PLFLT arg15 ;
8145 PLFLT arg16 ;
8146 PLFLT arg17 ;
8147 PLFLT arg18 ;
8148 PLINT *arg19 = 0 ;
8149 char **arg20 = 0 ;
8150 PLINT *arg21 = 0 ;
8151 PLINT *arg22 = 0 ;
8152 PLFLT *arg23 = 0 ;
8153 PLFLT *arg24 = 0 ;
8154 PLINT *arg25 = 0 ;
8155 PLINT *arg26 = 0 ;
8156 PLFLT *arg27 = 0 ;
8157 PLINT *arg28 = 0 ;
8158 PLFLT *arg29 = 0 ;
8159 PLINT *arg30 = 0 ;
8160 char **arg31 = 0 ;
8161 PLFLT temp1 ;
8162 int res1 = SWIG_TMPOBJ ;
8163 PLFLT temp2 ;
8164 int res2 = SWIG_TMPOBJ ;
8165 int val3 ;
8166 int ecode3 = 0 ;
8167 int val4 ;
8168 int ecode4 = 0 ;
8169 double val5 ;
8170 int ecode5 = 0 ;
8171 double val6 ;
8172 int ecode6 = 0 ;
8173 double val7 ;
8174 int ecode7 = 0 ;
8175 int val8 ;
8176 int ecode8 = 0 ;
8177 int val9 ;
8178 int ecode9 = 0 ;
8179 int val10 ;
8180 int ecode10 = 0 ;
8181 int val11 ;
8182 int ecode11 = 0 ;
8183 int val12 ;
8184 int ecode12 = 0 ;
8185 PyArrayObject *tmp13 = NULL ;
8186 double val15 ;
8187 int ecode15 = 0 ;
8188 double val16 ;
8189 int ecode16 = 0 ;
8190 double val17 ;
8191 int ecode17 = 0 ;
8192 double val18 ;
8193 int ecode18 = 0 ;
8194 PyArrayObject *tmp19 = NULL ;
8195 PyArrayObject *tmp20 = NULL ;
8196 PyArrayObject *tmp21 = NULL ;
8197 PyArrayObject *tmp22 = NULL ;
8198 PyArrayObject *tmp23 = NULL ;
8199 PyArrayObject *tmp24 = NULL ;
8200 PyArrayObject *tmp25 = NULL ;
8201 PyArrayObject *tmp26 = NULL ;
8202 PyArrayObject *tmp27 = NULL ;
8203 PyArrayObject *tmp28 = NULL ;
8204 PyArrayObject *tmp29 = NULL ;
8205 PyArrayObject *tmp30 = NULL ;
8206 PyArrayObject *tmp31 = NULL ;
8207 PyObject *swig_obj[28] ;
8208
8209 arg1 = &temp1;
8210 arg2 = &temp2;
8211 (void)self;
8212 if (!SWIG_Python_UnpackTuple(args, "pllegend", 28, 28, swig_obj)) SWIG_fail;
8213 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8214 if (!SWIG_IsOK(ecode3)) {
8215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
8216 }
8217 arg3 = (PLINT)(val3);
8218 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8219 if (!SWIG_IsOK(ecode4)) {
8220 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
8221 }
8222 arg4 = (PLINT)(val4);
8223 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8224 if (!SWIG_IsOK(ecode5)) {
8225 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
8226 }
8227 arg5 = (PLFLT)(val5);
8228 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8229 if (!SWIG_IsOK(ecode6)) {
8230 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
8231 }
8232 arg6 = (PLFLT)(val6);
8233 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8234 if (!SWIG_IsOK(ecode7)) {
8235 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
8236 }
8237 arg7 = (PLFLT)(val7);
8238 ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
8239 if (!SWIG_IsOK(ecode8)) {
8240 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
8241 }
8242 arg8 = (PLINT)(val8);
8243 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8244 if (!SWIG_IsOK(ecode9)) {
8245 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
8246 }
8247 arg9 = (PLINT)(val9);
8248 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8249 if (!SWIG_IsOK(ecode10)) {
8250 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
8251 }
8252 arg10 = (PLINT)(val10);
8253 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8254 if (!SWIG_IsOK(ecode11)) {
8255 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
8256 }
8257 arg11 = (PLINT)(val11);
8258 ecode12 = SWIG_AsVal_int(swig_obj[9], &val12);
8259 if (!SWIG_IsOK(ecode12)) {
8260 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
8261 }
8262 arg12 = (PLINT)(val12);
8263 {
8264 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[10], NPY_PLINT, 1, 1 );
8265 if ( tmp13 == NULL )
8266 return NULL;
8267 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
8268 arg14 = (PLINT *) PyArray_DATA( tmp13 );
8269 }
8270 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
8271 if (!SWIG_IsOK(ecode15)) {
8272 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
8273 }
8274 arg15 = (PLFLT)(val15);
8275 ecode16 = SWIG_AsVal_double(swig_obj[12], &val16);
8276 if (!SWIG_IsOK(ecode16)) {
8277 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
8278 }
8279 arg16 = (PLFLT)(val16);
8280 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
8281 if (!SWIG_IsOK(ecode17)) {
8282 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
8283 }
8284 arg17 = (PLFLT)(val17);
8285 ecode18 = SWIG_AsVal_double(swig_obj[14], &val18);
8286 if (!SWIG_IsOK(ecode18)) {
8287 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
8288 }
8289 arg18 = (PLFLT)(val18);
8290 {
8291 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[15], NPY_PLINT, 1, 1 );
8292 if ( tmp19 == NULL )
8293 return NULL;
8294 if ( PyArray_DIMS( tmp19 )[0] != Alen )
8295 {
8296 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8297 return NULL;
8298 }
8299 arg19 = (PLINT *) PyArray_DATA( tmp19 );
8300 }
8301 {
8302 int i;
8303 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[16], NPY_STRING, 1, 1 );
8304 if ( tmp20 == NULL )
8305 return NULL;
8306 if ( PyArray_DIMS( tmp20 )[0] != Alen )
8307 {
8308 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8309 return NULL;
8310 }
8311 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8312 for ( i = 0; i < Alen; i++ )
8313 {
8314 arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8315 if ( arg20[i] == NULL )
8316 {
8317 free( arg20 );
8318 return NULL;
8319 }
8320 }
8321 }
8322 {
8323 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8324 if ( tmp21 == NULL )
8325 return NULL;
8326 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8327 {
8328 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8329 return NULL;
8330 }
8331 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8332 }
8333 {
8334 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8335 if ( tmp22 == NULL )
8336 return NULL;
8337 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8338 {
8339 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8340 return NULL;
8341 }
8342 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8343 }
8344 {
8345 if ( swig_obj[19] != Py_None )
8346 {
8347 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 1, 1 );
8348 if ( tmp23 == NULL )
8349 return NULL;
8350 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8351 {
8352 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8353 return NULL;
8354 }
8355 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8356 }
8357 else
8358 {
8359 arg23 = NULL;
8360 }
8361 }
8362 {
8363 if ( swig_obj[20] != Py_None )
8364 {
8365 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[20], NPY_PLFLT, 1, 1 );
8366 if ( tmp24 == NULL )
8367 return NULL;
8368 if ( PyArray_DIMS( tmp24 )[0] != Alen )
8369 {
8370 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8371 return NULL;
8372 }
8373 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8374 }
8375 else
8376 {
8377 arg24 = NULL;
8378 }
8379 }
8380 {
8381 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[21], NPY_PLINT, 1, 1 );
8382 if ( tmp25 == NULL )
8383 return NULL;
8384 if ( PyArray_DIMS( tmp25 )[0] != Alen )
8385 {
8386 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8387 return NULL;
8388 }
8389 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8390 }
8391 {
8392 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[22], NPY_PLINT, 1, 1 );
8393 if ( tmp26 == NULL )
8394 return NULL;
8395 if ( PyArray_DIMS( tmp26 )[0] != Alen )
8396 {
8397 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8398 return NULL;
8399 }
8400 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8401 }
8402 {
8403 if ( swig_obj[23] != Py_None )
8404 {
8405 tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[23], NPY_PLFLT, 1, 1 );
8406 if ( tmp27 == NULL )
8407 return NULL;
8408 if ( PyArray_DIMS( tmp27 )[0] != Alen )
8409 {
8410 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8411 return NULL;
8412 }
8413 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8414 }
8415 else
8416 {
8417 arg27 = NULL;
8418 }
8419 }
8420 {
8421 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[24], NPY_PLINT, 1, 1 );
8422 if ( tmp28 == NULL )
8423 return NULL;
8424 if ( PyArray_DIMS( tmp28 )[0] != Alen )
8425 {
8426 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8427 return NULL;
8428 }
8429 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8430 }
8431 {
8432 if ( swig_obj[25] != Py_None )
8433 {
8434 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[25], NPY_PLFLT, 1, 1 );
8435 if ( tmp29 == NULL )
8436 return NULL;
8437 if ( PyArray_DIMS( tmp29 )[0] != Alen )
8438 {
8439 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8440 return NULL;
8441 }
8442 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8443 }
8444 else
8445 {
8446 arg29 = NULL;
8447 }
8448 }
8449 {
8450 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[26], NPY_PLINT, 1, 1 );
8451 if ( tmp30 == NULL )
8452 return NULL;
8453 if ( PyArray_DIMS( tmp30 )[0] != Alen )
8454 {
8455 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8456 return NULL;
8457 }
8458 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8459 }
8460 {
8461 int i;
8462 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[27], NPY_STRING, 1, 1 );
8463 if ( tmp31 == NULL )
8464 return NULL;
8465 if ( PyArray_DIMS( tmp31 )[0] != Alen )
8466 {
8467 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8468 return NULL;
8469 }
8470 arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8471 for ( i = 0; i < Alen; i++ )
8472 {
8473 arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8474 if ( arg31[i] == NULL )
8475 {
8476 free( arg31 );
8477 return NULL;
8478 }
8479 }
8480 }
8481 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);
8482 resultobj = SWIG_Py_Void();
8483 if (SWIG_IsTmpObj(res1)) {
8484 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
8485 } else {
8486 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
8488 }
8489 if (SWIG_IsTmpObj(res2)) {
8490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
8491 } else {
8492 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
8494 }
8495 {
8496 Py_CLEAR( tmp13 );
8497 }
8498 {
8499 Py_CLEAR( tmp19 );
8500 }
8501 {
8502 Py_CLEAR( tmp20 ); free( arg20 );
8503 }
8504 {
8505 Py_CLEAR( tmp21 );
8506 }
8507 {
8508 Py_CLEAR( tmp22 );
8509 }
8510 {
8511 Py_CLEAR( tmp23 );
8512 }
8513 {
8514 Py_CLEAR( tmp24 );
8515 }
8516 {
8517 Py_CLEAR( tmp25 );
8518 }
8519 {
8520 Py_CLEAR( tmp26 );
8521 }
8522 {
8523 Py_CLEAR( tmp27 );
8524 }
8525 {
8526 Py_CLEAR( tmp28 );
8527 }
8528 {
8529 Py_CLEAR( tmp29 );
8530 }
8531 {
8532 Py_CLEAR( tmp30 );
8533 }
8534 {
8535 Py_CLEAR( tmp31 ); free( arg31 );
8536 }
8537 return resultobj;
8538fail:
8539 {
8540 Py_CLEAR( tmp13 );
8541 }
8542 {
8543 Py_CLEAR( tmp19 );
8544 }
8545 {
8546 Py_CLEAR( tmp20 ); free( arg20 );
8547 }
8548 {
8549 Py_CLEAR( tmp21 );
8550 }
8551 {
8552 Py_CLEAR( tmp22 );
8553 }
8554 {
8555 Py_CLEAR( tmp23 );
8556 }
8557 {
8558 Py_CLEAR( tmp24 );
8559 }
8560 {
8561 Py_CLEAR( tmp25 );
8562 }
8563 {
8564 Py_CLEAR( tmp26 );
8565 }
8566 {
8567 Py_CLEAR( tmp27 );
8568 }
8569 {
8570 Py_CLEAR( tmp28 );
8571 }
8572 {
8573 Py_CLEAR( tmp29 );
8574 }
8575 {
8576 Py_CLEAR( tmp30 );
8577 }
8578 {
8579 Py_CLEAR( tmp31 ); free( arg31 );
8580 }
8581 return NULL;
8582}
8583
8584
8585SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *self, PyObject *args) {
8586 PyObject *resultobj = 0;
8587 PLFLT *arg1 = 0 ;
8588 PLFLT *arg2 = 0 ;
8589 PLINT arg3 ;
8590 PLINT arg4 ;
8591 PLFLT arg5 ;
8592 PLFLT arg6 ;
8593 PLFLT arg7 ;
8594 PLFLT arg8 ;
8595 PLINT arg9 ;
8596 PLINT arg10 ;
8597 PLINT arg11 ;
8598 PLFLT arg12 ;
8599 PLFLT arg13 ;
8600 PLINT arg14 ;
8601 PLFLT arg15 ;
8602 PLINT arg16 ;
8603 PLINT *arg17 = 0 ;
8604 char **arg18 = 0 ;
8605 PLINT arg19 ;
8606 char **arg20 = 0 ;
8607 PLFLT *arg21 = 0 ;
8608 PLINT *arg22 = 0 ;
8609 PLINT *arg23 = 0 ;
8610 PLFLT **arg24 = 0 ;
8611 PLFLT temp1 ;
8612 int res1 = SWIG_TMPOBJ ;
8613 PLFLT temp2 ;
8614 int res2 = SWIG_TMPOBJ ;
8615 int val3 ;
8616 int ecode3 = 0 ;
8617 int val4 ;
8618 int ecode4 = 0 ;
8619 double val5 ;
8620 int ecode5 = 0 ;
8621 double val6 ;
8622 int ecode6 = 0 ;
8623 double val7 ;
8624 int ecode7 = 0 ;
8625 double val8 ;
8626 int ecode8 = 0 ;
8627 int val9 ;
8628 int ecode9 = 0 ;
8629 int val10 ;
8630 int ecode10 = 0 ;
8631 int val11 ;
8632 int ecode11 = 0 ;
8633 double val12 ;
8634 int ecode12 = 0 ;
8635 double val13 ;
8636 int ecode13 = 0 ;
8637 int val14 ;
8638 int ecode14 = 0 ;
8639 double val15 ;
8640 int ecode15 = 0 ;
8641 PyArrayObject *tmp16 = NULL ;
8642 PyArrayObject *tmp18 = NULL ;
8643 PyArrayObject *tmp19 = NULL ;
8644 PyArrayObject *tmp21 = NULL ;
8645 PyArrayObject *tmp22 = NULL ;
8646 PyArrayObject *tmp23 = NULL ;
8647 PyArrayObject *tmp24 = NULL ;
8648 PyObject *swig_obj[20] ;
8649
8650 arg1 = &temp1;
8651 arg2 = &temp2;
8652 (void)self;
8653 if (!SWIG_Python_UnpackTuple(args, "plcolorbar", 20, 20, swig_obj)) SWIG_fail;
8654 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8655 if (!SWIG_IsOK(ecode3)) {
8656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8657 }
8658 arg3 = (PLINT)(val3);
8659 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8660 if (!SWIG_IsOK(ecode4)) {
8661 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8662 }
8663 arg4 = (PLINT)(val4);
8664 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8665 if (!SWIG_IsOK(ecode5)) {
8666 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8667 }
8668 arg5 = (PLFLT)(val5);
8669 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8670 if (!SWIG_IsOK(ecode6)) {
8671 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8672 }
8673 arg6 = (PLFLT)(val6);
8674 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8675 if (!SWIG_IsOK(ecode7)) {
8676 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8677 }
8678 arg7 = (PLFLT)(val7);
8679 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
8680 if (!SWIG_IsOK(ecode8)) {
8681 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8682 }
8683 arg8 = (PLFLT)(val8);
8684 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8685 if (!SWIG_IsOK(ecode9)) {
8686 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8687 }
8688 arg9 = (PLINT)(val9);
8689 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8690 if (!SWIG_IsOK(ecode10)) {
8691 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8692 }
8693 arg10 = (PLINT)(val10);
8694 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8695 if (!SWIG_IsOK(ecode11)) {
8696 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8697 }
8698 arg11 = (PLINT)(val11);
8699 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
8700 if (!SWIG_IsOK(ecode12)) {
8701 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8702 }
8703 arg12 = (PLFLT)(val12);
8704 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
8705 if (!SWIG_IsOK(ecode13)) {
8706 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8707 }
8708 arg13 = (PLFLT)(val13);
8709 ecode14 = SWIG_AsVal_int(swig_obj[11], &val14);
8710 if (!SWIG_IsOK(ecode14)) {
8711 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8712 }
8713 arg14 = (PLINT)(val14);
8714 ecode15 = SWIG_AsVal_double(swig_obj[12], &val15);
8715 if (!SWIG_IsOK(ecode15)) {
8716 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8717 }
8718 arg15 = (PLFLT)(val15);
8719 {
8720 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
8721 if ( tmp16 == NULL )
8722 return NULL;
8723 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8724 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8725 }
8726 {
8727 int i;
8728 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[14], NPY_STRING, 1, 1 );
8729 if ( tmp18 == NULL )
8730 return NULL;
8731 if ( PyArray_DIMS( tmp18 )[0] != Alen )
8732 {
8733 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8734 return NULL;
8735 }
8736 arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8737 for ( i = 0; i < Alen; i++ )
8738 {
8739 arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8740 if ( arg18[i] == NULL )
8741 {
8742 free( arg18 );
8743 return NULL;
8744 }
8745 }
8746 }
8747 {
8748 int i;
8749 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[15], NPY_STRING, 1, 1 );
8750 if ( tmp19 == NULL )
8751 return NULL;
8752 Alen = PyArray_DIMS( tmp19 )[0];
8753 arg19 = Alen;
8754 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8755 for ( i = 0; i < Alen; i++ )
8756 {
8757 arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8758 if ( arg20[i] == NULL )
8759 {
8760 free( arg20 );
8761 return NULL;
8762 }
8763 }
8764 }
8765 {
8766 tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[16], NPY_PLFLT, 1, 1 );
8767 if ( tmp21 == NULL )
8768 return NULL;
8769 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8770 {
8771 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8772 return NULL;
8773 }
8774 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8775 }
8776 {
8777 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8778 if ( tmp22 == NULL )
8779 return NULL;
8780 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8781 {
8782 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8783 return NULL;
8784 }
8785 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8786 }
8787 {
8788 int i;
8789 tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8790 if ( tmp23 == NULL )
8791 return NULL;
8792 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8793 {
8794 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8795 return NULL;
8796 }
8797 Xlen = PyArray_DIMS( tmp23 )[0];
8798 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8799 Ylen = -1;
8800 for ( i = 0; i < Xlen; i++ )
8801 if ( arg23[i] > Ylen )
8802 Ylen = arg23[i];
8803 }
8804 {
8805 int i, size;
8806 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 2, 2 );
8807 if ( tmp24 == NULL )
8808 return NULL;
8809 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8810 {
8811 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8812 return NULL;
8813 }
8814 size = Ylen;
8815 arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8816 for ( i = 0; i < Xlen; i++ )
8817 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8818 }
8819 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);
8820 resultobj = SWIG_Py_Void();
8821 if (SWIG_IsTmpObj(res1)) {
8822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
8823 } else {
8824 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
8826 }
8827 if (SWIG_IsTmpObj(res2)) {
8828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
8829 } else {
8830 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8831 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
8832 }
8833 {
8834 Py_CLEAR( tmp16 );
8835 }
8836 {
8837 Py_CLEAR( tmp18 ); free( arg18 );
8838 }
8839 {
8840 Py_CLEAR( tmp19 ); free( arg20 );
8841 }
8842 {
8843 Py_CLEAR( tmp21 );
8844 }
8845 {
8846 Py_CLEAR( tmp22 );
8847 }
8848 {
8849 Py_CLEAR( tmp23 );
8850 }
8851 {
8852 Py_CLEAR( tmp24 );
8853 free( arg24 );
8854 }
8855 return resultobj;
8856fail:
8857 {
8858 Py_CLEAR( tmp16 );
8859 }
8860 {
8861 Py_CLEAR( tmp18 ); free( arg18 );
8862 }
8863 {
8864 Py_CLEAR( tmp19 ); free( arg20 );
8865 }
8866 {
8867 Py_CLEAR( tmp21 );
8868 }
8869 {
8870 Py_CLEAR( tmp22 );
8871 }
8872 {
8873 Py_CLEAR( tmp23 );
8874 }
8875 {
8876 Py_CLEAR( tmp24 );
8877 free( arg24 );
8878 }
8879 return NULL;
8880}
8881
8882
8883SWIGINTERN PyObject *_wrap_pllightsource(PyObject *self, PyObject *args) {
8884 PyObject *resultobj = 0;
8885 PLFLT arg1 ;
8886 PLFLT arg2 ;
8887 PLFLT arg3 ;
8888 double val1 ;
8889 int ecode1 = 0 ;
8890 double val2 ;
8891 int ecode2 = 0 ;
8892 double val3 ;
8893 int ecode3 = 0 ;
8894 PyObject *swig_obj[3] ;
8895
8896 (void)self;
8897 if (!SWIG_Python_UnpackTuple(args, "pllightsource", 3, 3, swig_obj)) SWIG_fail;
8898 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8899 if (!SWIG_IsOK(ecode1)) {
8900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8901 }
8902 arg1 = (PLFLT)(val1);
8903 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8904 if (!SWIG_IsOK(ecode2)) {
8905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8906 }
8907 arg2 = (PLFLT)(val2);
8908 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8909 if (!SWIG_IsOK(ecode3)) {
8910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8911 }
8912 arg3 = (PLFLT)(val3);
8913 pllightsource(arg1,arg2,arg3);
8914 resultobj = SWIG_Py_Void();
8915 return resultobj;
8916fail:
8917 return NULL;
8918}
8919
8920
8921SWIGINTERN PyObject *_wrap_plline(PyObject *self, PyObject *args) {
8922 PyObject *resultobj = 0;
8923 PLINT arg1 ;
8924 PLFLT *arg2 = 0 ;
8925 PLFLT *arg3 = 0 ;
8926 PyArrayObject *tmp1 = NULL ;
8927 PyArrayObject *tmp3 = NULL ;
8928 PyObject *swig_obj[2] ;
8929
8930 (void)self;
8931 if (!SWIG_Python_UnpackTuple(args, "plline", 2, 2, swig_obj)) SWIG_fail;
8932 {
8933 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8934 if ( tmp1 == NULL )
8935 return NULL;
8936 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8937 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8938 }
8939 {
8940 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8941 if ( tmp3 == NULL )
8942 return NULL;
8943 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8944 {
8945 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8946 return NULL;
8947 }
8948 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8949 }
8950 plline(arg1,(double const *)arg2,(double const *)arg3);
8951 resultobj = SWIG_Py_Void();
8952 {
8953 Py_CLEAR( tmp1 );
8954 }
8955 {
8956 Py_CLEAR( tmp3 );
8957 }
8958 return resultobj;
8959fail:
8960 {
8961 Py_CLEAR( tmp1 );
8962 }
8963 {
8964 Py_CLEAR( tmp3 );
8965 }
8966 return NULL;
8967}
8968
8969
8970SWIGINTERN PyObject *_wrap_plline3(PyObject *self, PyObject *args) {
8971 PyObject *resultobj = 0;
8972 PLINT arg1 ;
8973 PLFLT *arg2 = 0 ;
8974 PLFLT *arg3 = 0 ;
8975 PLFLT *arg4 = 0 ;
8976 PyArrayObject *tmp1 = NULL ;
8977 PyArrayObject *tmp3 = NULL ;
8978 PyArrayObject *tmp4 = NULL ;
8979 PyObject *swig_obj[3] ;
8980
8981 (void)self;
8982 if (!SWIG_Python_UnpackTuple(args, "plline3", 3, 3, swig_obj)) SWIG_fail;
8983 {
8984 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8985 if ( tmp1 == NULL )
8986 return NULL;
8987 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8988 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8989 }
8990 {
8991 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8992 if ( tmp3 == NULL )
8993 return NULL;
8994 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8995 {
8996 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8997 return NULL;
8998 }
8999 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
9000 }
9001 {
9002 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9003 if ( tmp4 == NULL )
9004 return NULL;
9005 if ( PyArray_DIMS( tmp4 )[0] != Alen )
9006 {
9007 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9008 return NULL;
9009 }
9010 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9011 }
9012 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
9013 resultobj = SWIG_Py_Void();
9014 {
9015 Py_CLEAR( tmp1 );
9016 }
9017 {
9018 Py_CLEAR( tmp3 );
9019 }
9020 {
9021 Py_CLEAR( tmp4 );
9022 }
9023 return resultobj;
9024fail:
9025 {
9026 Py_CLEAR( tmp1 );
9027 }
9028 {
9029 Py_CLEAR( tmp3 );
9030 }
9031 {
9032 Py_CLEAR( tmp4 );
9033 }
9034 return NULL;
9035}
9036
9037
9038SWIGINTERN PyObject *_wrap_pllsty(PyObject *self, PyObject *args) {
9039 PyObject *resultobj = 0;
9040 PLINT arg1 ;
9041 int val1 ;
9042 int ecode1 = 0 ;
9043 PyObject *swig_obj[1] ;
9044
9045 (void)self;
9046 if (!args) SWIG_fail;
9047 swig_obj[0] = args;
9048 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9049 if (!SWIG_IsOK(ecode1)) {
9050 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
9051 }
9052 arg1 = (PLINT)(val1);
9053 pllsty(arg1);
9054 resultobj = SWIG_Py_Void();
9055 return resultobj;
9056fail:
9057 return NULL;
9058}
9059
9060
9061SWIGINTERN PyObject *_wrap_plmesh(PyObject *self, PyObject *args) {
9062 PyObject *resultobj = 0;
9063 PLFLT *arg1 = 0 ;
9064 PLFLT *arg2 = 0 ;
9065 PLFLT **arg3 = 0 ;
9066 PLINT arg4 ;
9067 PLINT arg5 ;
9068 PLINT arg6 ;
9069 PyArrayObject *tmp1 = NULL ;
9070 PyArrayObject *tmp2 = NULL ;
9071 PyArrayObject *tmp3 = NULL ;
9072 int val6 ;
9073 int ecode6 = 0 ;
9074 PyObject *swig_obj[4] ;
9075
9076 (void)self;
9077 if (!SWIG_Python_UnpackTuple(args, "plmesh", 4, 4, swig_obj)) SWIG_fail;
9078 {
9079 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9080 if ( tmp1 == NULL )
9081 return NULL;
9082 Xlen = PyArray_DIMS( tmp1 )[0];
9083 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9084 }
9085 {
9086 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9087 if ( tmp2 == NULL )
9088 return NULL;
9089 Ylen = PyArray_DIMS( tmp2 )[0];
9090 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9091 }
9092 {
9093 int i, size;
9094 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9095 if ( tmp3 == NULL )
9096 return NULL;
9097 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9098 {
9099 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9100 return NULL;
9101 }
9102 arg4 = PyArray_DIMS( tmp3 )[0];
9103 arg5 = PyArray_DIMS( tmp3 )[1];
9104 size = arg5;
9105 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9106 for ( i = 0; i < arg4; i++ )
9107 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9108 }
9109 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9110 if (!SWIG_IsOK(ecode6)) {
9111 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
9112 }
9113 arg6 = (PLINT)(val6);
9114 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
9115 resultobj = SWIG_Py_Void();
9116 {
9117 Py_CLEAR( tmp1 );
9118 }
9119 {
9120 Py_CLEAR( tmp2 );
9121 }
9122 {
9123 Py_CLEAR( tmp3 );
9124 free( arg3 );
9125 }
9126 return resultobj;
9127fail:
9128 {
9129 Py_CLEAR( tmp1 );
9130 }
9131 {
9132 Py_CLEAR( tmp2 );
9133 }
9134 {
9135 Py_CLEAR( tmp3 );
9136 free( arg3 );
9137 }
9138 return NULL;
9139}
9140
9141
9142SWIGINTERN PyObject *_wrap_plmeshc(PyObject *self, PyObject *args) {
9143 PyObject *resultobj = 0;
9144 PLFLT *arg1 = 0 ;
9145 PLFLT *arg2 = 0 ;
9146 PLFLT **arg3 = 0 ;
9147 PLINT arg4 ;
9148 PLINT arg5 ;
9149 PLINT arg6 ;
9150 PLFLT *arg7 = 0 ;
9151 PLINT arg8 ;
9152 PyArrayObject *tmp1 = NULL ;
9153 PyArrayObject *tmp2 = NULL ;
9154 PyArrayObject *tmp3 = NULL ;
9155 int val6 ;
9156 int ecode6 = 0 ;
9157 PyArrayObject *tmp7 = NULL ;
9158 PyObject *swig_obj[5] ;
9159
9160 (void)self;
9161 if (!SWIG_Python_UnpackTuple(args, "plmeshc", 5, 5, swig_obj)) SWIG_fail;
9162 {
9163 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9164 if ( tmp1 == NULL )
9165 return NULL;
9166 Xlen = PyArray_DIMS( tmp1 )[0];
9167 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9168 }
9169 {
9170 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9171 if ( tmp2 == NULL )
9172 return NULL;
9173 Ylen = PyArray_DIMS( tmp2 )[0];
9174 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9175 }
9176 {
9177 int i, size;
9178 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9179 if ( tmp3 == NULL )
9180 return NULL;
9181 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9182 {
9183 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9184 return NULL;
9185 }
9186 arg4 = PyArray_DIMS( tmp3 )[0];
9187 arg5 = PyArray_DIMS( tmp3 )[1];
9188 size = arg5;
9189 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9190 for ( i = 0; i < arg4; i++ )
9191 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9192 }
9193 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9194 if (!SWIG_IsOK(ecode6)) {
9195 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9196 }
9197 arg6 = (PLINT)(val6);
9198 {
9199 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9200 if ( tmp7 == NULL )
9201 return NULL;
9202 arg8 = PyArray_DIMS( tmp7 )[0];
9203 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9204 }
9205 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9206 resultobj = SWIG_Py_Void();
9207 {
9208 Py_CLEAR( tmp1 );
9209 }
9210 {
9211 Py_CLEAR( tmp2 );
9212 }
9213 {
9214 Py_CLEAR( tmp3 );
9215 free( arg3 );
9216 }
9217 {
9218 Py_CLEAR( tmp7 );
9219 }
9220 return resultobj;
9221fail:
9222 {
9223 Py_CLEAR( tmp1 );
9224 }
9225 {
9226 Py_CLEAR( tmp2 );
9227 }
9228 {
9229 Py_CLEAR( tmp3 );
9230 free( arg3 );
9231 }
9232 {
9233 Py_CLEAR( tmp7 );
9234 }
9235 return NULL;
9236}
9237
9238
9239SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *self, PyObject *args) {
9240 PyObject *resultobj = 0;
9241 PLINT *arg1 = 0 ;
9242 PLINT temp1 ;
9243 int res1 = SWIG_TMPOBJ ;
9244
9245 arg1 = &temp1;
9246 (void)self;
9247 if (!SWIG_Python_UnpackTuple(args, "plmkstrm", 0, 0, 0)) SWIG_fail;
9248 plmkstrm(arg1);
9249 resultobj = SWIG_Py_Void();
9250 if (SWIG_IsTmpObj(res1)) {
9251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
9252 } else {
9253 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
9255 }
9256 return resultobj;
9257fail:
9258 return NULL;
9259}
9260
9261
9262SWIGINTERN PyObject *_wrap_plmtex(PyObject *self, PyObject *args) {
9263 PyObject *resultobj = 0;
9264 char *arg1 = 0 ;
9265 PLFLT arg2 ;
9266 PLFLT arg3 ;
9267 PLFLT arg4 ;
9268 char *arg5 = 0 ;
9269 int res1 ;
9270 char *buf1 = 0 ;
9271 int alloc1 = 0 ;
9272 double val2 ;
9273 int ecode2 = 0 ;
9274 double val3 ;
9275 int ecode3 = 0 ;
9276 double val4 ;
9277 int ecode4 = 0 ;
9278 int res5 ;
9279 char *buf5 = 0 ;
9280 int alloc5 = 0 ;
9281 PyObject *swig_obj[5] ;
9282
9283 (void)self;
9284 if (!SWIG_Python_UnpackTuple(args, "plmtex", 5, 5, swig_obj)) SWIG_fail;
9285 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9286 if (!SWIG_IsOK(res1)) {
9287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
9288 }
9289 arg1 = (char *)(buf1);
9290 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9291 if (!SWIG_IsOK(ecode2)) {
9292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9293 }
9294 arg2 = (PLFLT)(val2);
9295 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9296 if (!SWIG_IsOK(ecode3)) {
9297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9298 }
9299 arg3 = (PLFLT)(val3);
9300 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9301 if (!SWIG_IsOK(ecode4)) {
9302 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9303 }
9304 arg4 = (PLFLT)(val4);
9305 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9306 if (!SWIG_IsOK(res5)) {
9307 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9308 }
9309 arg5 = (char *)(buf5);
9310 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9311 resultobj = SWIG_Py_Void();
9312 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9313 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9314 return resultobj;
9315fail:
9316 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9317 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9318 return NULL;
9319}
9320
9321
9322SWIGINTERN PyObject *_wrap_plmtex3(PyObject *self, PyObject *args) {
9323 PyObject *resultobj = 0;
9324 char *arg1 = 0 ;
9325 PLFLT arg2 ;
9326 PLFLT arg3 ;
9327 PLFLT arg4 ;
9328 char *arg5 = 0 ;
9329 int res1 ;
9330 char *buf1 = 0 ;
9331 int alloc1 = 0 ;
9332 double val2 ;
9333 int ecode2 = 0 ;
9334 double val3 ;
9335 int ecode3 = 0 ;
9336 double val4 ;
9337 int ecode4 = 0 ;
9338 int res5 ;
9339 char *buf5 = 0 ;
9340 int alloc5 = 0 ;
9341 PyObject *swig_obj[5] ;
9342
9343 (void)self;
9344 if (!SWIG_Python_UnpackTuple(args, "plmtex3", 5, 5, swig_obj)) SWIG_fail;
9345 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9346 if (!SWIG_IsOK(res1)) {
9347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9348 }
9349 arg1 = (char *)(buf1);
9350 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9351 if (!SWIG_IsOK(ecode2)) {
9352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9353 }
9354 arg2 = (PLFLT)(val2);
9355 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9356 if (!SWIG_IsOK(ecode3)) {
9357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9358 }
9359 arg3 = (PLFLT)(val3);
9360 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9361 if (!SWIG_IsOK(ecode4)) {
9362 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9363 }
9364 arg4 = (PLFLT)(val4);
9365 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9366 if (!SWIG_IsOK(res5)) {
9367 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9368 }
9369 arg5 = (char *)(buf5);
9370 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9371 resultobj = SWIG_Py_Void();
9372 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9373 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9374 return resultobj;
9375fail:
9376 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9377 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9378 return NULL;
9379}
9380
9381
9382SWIGINTERN PyObject *_wrap_plot3d(PyObject *self, PyObject *args) {
9383 PyObject *resultobj = 0;
9384 PLFLT *arg1 = 0 ;
9385 PLFLT *arg2 = 0 ;
9386 PLFLT **arg3 = 0 ;
9387 PLINT arg4 ;
9388 PLINT arg5 ;
9389 PLINT arg6 ;
9390 PLBOOL arg7 ;
9391 PyArrayObject *tmp1 = NULL ;
9392 PyArrayObject *tmp2 = NULL ;
9393 PyArrayObject *tmp3 = NULL ;
9394 int val6 ;
9395 int ecode6 = 0 ;
9396 int val7 ;
9397 int ecode7 = 0 ;
9398 PyObject *swig_obj[5] ;
9399
9400 (void)self;
9401 if (!SWIG_Python_UnpackTuple(args, "plot3d", 5, 5, swig_obj)) SWIG_fail;
9402 {
9403 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9404 if ( tmp1 == NULL )
9405 return NULL;
9406 Xlen = PyArray_DIMS( tmp1 )[0];
9407 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9408 }
9409 {
9410 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9411 if ( tmp2 == NULL )
9412 return NULL;
9413 Ylen = PyArray_DIMS( tmp2 )[0];
9414 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9415 }
9416 {
9417 int i, size;
9418 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9419 if ( tmp3 == NULL )
9420 return NULL;
9421 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9422 {
9423 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9424 return NULL;
9425 }
9426 arg4 = PyArray_DIMS( tmp3 )[0];
9427 arg5 = PyArray_DIMS( tmp3 )[1];
9428 size = arg5;
9429 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9430 for ( i = 0; i < arg4; i++ )
9431 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9432 }
9433 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9434 if (!SWIG_IsOK(ecode6)) {
9435 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9436 }
9437 arg6 = (PLINT)(val6);
9438 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
9439 if (!SWIG_IsOK(ecode7)) {
9440 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9441 }
9442 arg7 = (PLBOOL)(val7);
9443 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9444 resultobj = SWIG_Py_Void();
9445 {
9446 Py_CLEAR( tmp1 );
9447 }
9448 {
9449 Py_CLEAR( tmp2 );
9450 }
9451 {
9452 Py_CLEAR( tmp3 );
9453 free( arg3 );
9454 }
9455 return resultobj;
9456fail:
9457 {
9458 Py_CLEAR( tmp1 );
9459 }
9460 {
9461 Py_CLEAR( tmp2 );
9462 }
9463 {
9464 Py_CLEAR( tmp3 );
9465 free( arg3 );
9466 }
9467 return NULL;
9468}
9469
9470
9471SWIGINTERN PyObject *_wrap_plot3dc(PyObject *self, PyObject *args) {
9472 PyObject *resultobj = 0;
9473 PLFLT *arg1 = 0 ;
9474 PLFLT *arg2 = 0 ;
9475 PLFLT **arg3 = 0 ;
9476 PLINT arg4 ;
9477 PLINT arg5 ;
9478 PLINT arg6 ;
9479 PLFLT *arg7 = 0 ;
9480 PLINT arg8 ;
9481 PyArrayObject *tmp1 = NULL ;
9482 PyArrayObject *tmp2 = NULL ;
9483 PyArrayObject *tmp3 = NULL ;
9484 int val6 ;
9485 int ecode6 = 0 ;
9486 PyArrayObject *tmp7 = NULL ;
9487 PyObject *swig_obj[5] ;
9488
9489 (void)self;
9490 if (!SWIG_Python_UnpackTuple(args, "plot3dc", 5, 5, swig_obj)) SWIG_fail;
9491 {
9492 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9493 if ( tmp1 == NULL )
9494 return NULL;
9495 Xlen = PyArray_DIMS( tmp1 )[0];
9496 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9497 }
9498 {
9499 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9500 if ( tmp2 == NULL )
9501 return NULL;
9502 Ylen = PyArray_DIMS( tmp2 )[0];
9503 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9504 }
9505 {
9506 int i, size;
9507 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9508 if ( tmp3 == NULL )
9509 return NULL;
9510 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9511 {
9512 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9513 return NULL;
9514 }
9515 arg4 = PyArray_DIMS( tmp3 )[0];
9516 arg5 = PyArray_DIMS( tmp3 )[1];
9517 size = arg5;
9518 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9519 for ( i = 0; i < arg4; i++ )
9520 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9521 }
9522 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9523 if (!SWIG_IsOK(ecode6)) {
9524 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9525 }
9526 arg6 = (PLINT)(val6);
9527 {
9528 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9529 if ( tmp7 == NULL )
9530 return NULL;
9531 arg8 = PyArray_DIMS( tmp7 )[0];
9532 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9533 }
9534 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9535 resultobj = SWIG_Py_Void();
9536 {
9537 Py_CLEAR( tmp1 );
9538 }
9539 {
9540 Py_CLEAR( tmp2 );
9541 }
9542 {
9543 Py_CLEAR( tmp3 );
9544 free( arg3 );
9545 }
9546 {
9547 Py_CLEAR( tmp7 );
9548 }
9549 return resultobj;
9550fail:
9551 {
9552 Py_CLEAR( tmp1 );
9553 }
9554 {
9555 Py_CLEAR( tmp2 );
9556 }
9557 {
9558 Py_CLEAR( tmp3 );
9559 free( arg3 );
9560 }
9561 {
9562 Py_CLEAR( tmp7 );
9563 }
9564 return NULL;
9565}
9566
9567
9568SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *self, PyObject *args) {
9569 PyObject *resultobj = 0;
9570 PLFLT *arg1 = 0 ;
9571 PLFLT *arg2 = 0 ;
9572 PLFLT **arg3 = 0 ;
9573 PLINT arg4 ;
9574 PLINT arg5 ;
9575 PLINT arg6 ;
9576 PLFLT *arg7 = 0 ;
9577 PLINT arg8 ;
9578 PLINT arg9 ;
9579 PLINT arg10 ;
9580 PLINT *arg11 = 0 ;
9581 PLINT *arg12 = 0 ;
9582 PyArrayObject *tmp1 = NULL ;
9583 PyArrayObject *tmp2 = NULL ;
9584 PyArrayObject *tmp3 = NULL ;
9585 int val6 ;
9586 int ecode6 = 0 ;
9587 PyArrayObject *tmp7 = NULL ;
9588 int val9 ;
9589 int ecode9 = 0 ;
9590 PyArrayObject *tmp10 = NULL ;
9591 PyArrayObject *tmp12 = NULL ;
9592 PyObject *swig_obj[8] ;
9593
9594 (void)self;
9595 if (!SWIG_Python_UnpackTuple(args, "plot3dcl", 8, 8, swig_obj)) SWIG_fail;
9596 {
9597 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9598 if ( tmp1 == NULL )
9599 return NULL;
9600 Xlen = PyArray_DIMS( tmp1 )[0];
9601 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9602 }
9603 {
9604 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9605 if ( tmp2 == NULL )
9606 return NULL;
9607 Ylen = PyArray_DIMS( tmp2 )[0];
9608 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9609 }
9610 {
9611 int i, size;
9612 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9613 if ( tmp3 == NULL )
9614 return NULL;
9615 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9616 {
9617 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9618 return NULL;
9619 }
9620 arg4 = PyArray_DIMS( tmp3 )[0];
9621 arg5 = PyArray_DIMS( tmp3 )[1];
9622 size = arg5;
9623 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9624 for ( i = 0; i < arg4; i++ )
9625 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9626 }
9627 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9628 if (!SWIG_IsOK(ecode6)) {
9629 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9630 }
9631 arg6 = (PLINT)(val6);
9632 {
9633 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9634 if ( tmp7 == NULL )
9635 return NULL;
9636 arg8 = PyArray_DIMS( tmp7 )[0];
9637 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9638 }
9639 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9640 if (!SWIG_IsOK(ecode9)) {
9641 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9642 }
9643 arg9 = (PLINT)(val9);
9644 {
9645 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9646 if ( tmp10 == NULL )
9647 return NULL;
9648 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9649 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9650 }
9651 {
9652 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9653 if ( tmp12 == NULL )
9654 return NULL;
9655 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9656 {
9657 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9658 return NULL;
9659 }
9660 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9661 }
9662 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);
9663 resultobj = SWIG_Py_Void();
9664 {
9665 Py_CLEAR( tmp1 );
9666 }
9667 {
9668 Py_CLEAR( tmp2 );
9669 }
9670 {
9671 Py_CLEAR( tmp3 );
9672 free( arg3 );
9673 }
9674 {
9675 Py_CLEAR( tmp7 );
9676 }
9677 {
9678 Py_CLEAR( tmp10 );
9679 }
9680 {
9681 Py_CLEAR( tmp12 );
9682 }
9683 return resultobj;
9684fail:
9685 {
9686 Py_CLEAR( tmp1 );
9687 }
9688 {
9689 Py_CLEAR( tmp2 );
9690 }
9691 {
9692 Py_CLEAR( tmp3 );
9693 free( arg3 );
9694 }
9695 {
9696 Py_CLEAR( tmp7 );
9697 }
9698 {
9699 Py_CLEAR( tmp10 );
9700 }
9701 {
9702 Py_CLEAR( tmp12 );
9703 }
9704 return NULL;
9705}
9706
9707
9708SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *self, PyObject *args) {
9709 PyObject *resultobj = 0;
9710 PLFLT *arg1 = 0 ;
9711 PLFLT *arg2 = 0 ;
9712 PLFLT **arg3 = 0 ;
9713 PLINT arg4 ;
9714 PLINT arg5 ;
9715 PLINT arg6 ;
9716 PLFLT *arg7 = 0 ;
9717 PLINT arg8 ;
9718 PyArrayObject *tmp1 = NULL ;
9719 PyArrayObject *tmp2 = NULL ;
9720 PyArrayObject *tmp3 = NULL ;
9721 int val6 ;
9722 int ecode6 = 0 ;
9723 PyArrayObject *tmp7 = NULL ;
9724 PyObject *swig_obj[5] ;
9725
9726 (void)self;
9727 if (!SWIG_Python_UnpackTuple(args, "plsurf3d", 5, 5, swig_obj)) SWIG_fail;
9728 {
9729 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9730 if ( tmp1 == NULL )
9731 return NULL;
9732 Xlen = PyArray_DIMS( tmp1 )[0];
9733 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9734 }
9735 {
9736 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9737 if ( tmp2 == NULL )
9738 return NULL;
9739 Ylen = PyArray_DIMS( tmp2 )[0];
9740 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9741 }
9742 {
9743 int i, size;
9744 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9745 if ( tmp3 == NULL )
9746 return NULL;
9747 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9748 {
9749 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9750 return NULL;
9751 }
9752 arg4 = PyArray_DIMS( tmp3 )[0];
9753 arg5 = PyArray_DIMS( tmp3 )[1];
9754 size = arg5;
9755 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9756 for ( i = 0; i < arg4; i++ )
9757 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9758 }
9759 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9760 if (!SWIG_IsOK(ecode6)) {
9761 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9762 }
9763 arg6 = (PLINT)(val6);
9764 {
9765 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9766 if ( tmp7 == NULL )
9767 return NULL;
9768 arg8 = PyArray_DIMS( tmp7 )[0];
9769 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9770 }
9771 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9772 resultobj = SWIG_Py_Void();
9773 {
9774 Py_CLEAR( tmp1 );
9775 }
9776 {
9777 Py_CLEAR( tmp2 );
9778 }
9779 {
9780 Py_CLEAR( tmp3 );
9781 free( arg3 );
9782 }
9783 {
9784 Py_CLEAR( tmp7 );
9785 }
9786 return resultobj;
9787fail:
9788 {
9789 Py_CLEAR( tmp1 );
9790 }
9791 {
9792 Py_CLEAR( tmp2 );
9793 }
9794 {
9795 Py_CLEAR( tmp3 );
9796 free( arg3 );
9797 }
9798 {
9799 Py_CLEAR( tmp7 );
9800 }
9801 return NULL;
9802}
9803
9804
9805SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *self, PyObject *args) {
9806 PyObject *resultobj = 0;
9807 PLFLT *arg1 = 0 ;
9808 PLFLT *arg2 = 0 ;
9809 PLFLT **arg3 = 0 ;
9810 PLINT arg4 ;
9811 PLINT arg5 ;
9812 PLINT arg6 ;
9813 PLFLT *arg7 = 0 ;
9814 PLINT arg8 ;
9815 PLINT arg9 ;
9816 PLINT arg10 ;
9817 PLINT *arg11 = 0 ;
9818 PLINT *arg12 = 0 ;
9819 PyArrayObject *tmp1 = NULL ;
9820 PyArrayObject *tmp2 = NULL ;
9821 PyArrayObject *tmp3 = NULL ;
9822 int val6 ;
9823 int ecode6 = 0 ;
9824 PyArrayObject *tmp7 = NULL ;
9825 int val9 ;
9826 int ecode9 = 0 ;
9827 PyArrayObject *tmp10 = NULL ;
9828 PyArrayObject *tmp12 = NULL ;
9829 PyObject *swig_obj[8] ;
9830
9831 (void)self;
9832 if (!SWIG_Python_UnpackTuple(args, "plsurf3dl", 8, 8, swig_obj)) SWIG_fail;
9833 {
9834 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9835 if ( tmp1 == NULL )
9836 return NULL;
9837 Xlen = PyArray_DIMS( tmp1 )[0];
9838 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9839 }
9840 {
9841 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9842 if ( tmp2 == NULL )
9843 return NULL;
9844 Ylen = PyArray_DIMS( tmp2 )[0];
9845 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9846 }
9847 {
9848 int i, size;
9849 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9850 if ( tmp3 == NULL )
9851 return NULL;
9852 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9853 {
9854 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9855 return NULL;
9856 }
9857 arg4 = PyArray_DIMS( tmp3 )[0];
9858 arg5 = PyArray_DIMS( tmp3 )[1];
9859 size = arg5;
9860 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9861 for ( i = 0; i < arg4; i++ )
9862 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9863 }
9864 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9865 if (!SWIG_IsOK(ecode6)) {
9866 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9867 }
9868 arg6 = (PLINT)(val6);
9869 {
9870 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9871 if ( tmp7 == NULL )
9872 return NULL;
9873 arg8 = PyArray_DIMS( tmp7 )[0];
9874 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9875 }
9876 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9877 if (!SWIG_IsOK(ecode9)) {
9878 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9879 }
9880 arg9 = (PLINT)(val9);
9881 {
9882 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9883 if ( tmp10 == NULL )
9884 return NULL;
9885 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9886 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9887 }
9888 {
9889 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9890 if ( tmp12 == NULL )
9891 return NULL;
9892 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9893 {
9894 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9895 return NULL;
9896 }
9897 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9898 }
9899 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);
9900 resultobj = SWIG_Py_Void();
9901 {
9902 Py_CLEAR( tmp1 );
9903 }
9904 {
9905 Py_CLEAR( tmp2 );
9906 }
9907 {
9908 Py_CLEAR( tmp3 );
9909 free( arg3 );
9910 }
9911 {
9912 Py_CLEAR( tmp7 );
9913 }
9914 {
9915 Py_CLEAR( tmp10 );
9916 }
9917 {
9918 Py_CLEAR( tmp12 );
9919 }
9920 return resultobj;
9921fail:
9922 {
9923 Py_CLEAR( tmp1 );
9924 }
9925 {
9926 Py_CLEAR( tmp2 );
9927 }
9928 {
9929 Py_CLEAR( tmp3 );
9930 free( arg3 );
9931 }
9932 {
9933 Py_CLEAR( tmp7 );
9934 }
9935 {
9936 Py_CLEAR( tmp10 );
9937 }
9938 {
9939 Py_CLEAR( tmp12 );
9940 }
9941 return NULL;
9942}
9943
9944
9945SWIGINTERN PyObject *_wrap_plparseopts(PyObject *self, PyObject *args) {
9946 PyObject *resultobj = 0;
9947 int *arg1 = 0 ;
9948 char **arg2 = 0 ;
9949 PLINT arg3 ;
9950 int tmp1 ;
9951 int val3 ;
9952 int ecode3 = 0 ;
9953 PyObject *swig_obj[2] ;
9954 PLINT result;
9955
9956 (void)self;
9957 if (!SWIG_Python_UnpackTuple(args, "plparseopts", 2, 2, swig_obj)) SWIG_fail;
9958 {
9959 int i;
9960 PyObject *unicode_string;
9961
9962 if ( !PyList_Check( swig_obj[0] ) )
9963 {
9964 PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9965 return NULL;
9966 }
9967 tmp1 = PyList_Size( swig_obj[0] );
9968 arg1 = &tmp1;
9969 arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9970 for ( i = 0; i < tmp1; i++ )
9971 {
9972 PyObject *s = PyList_GetItem( swig_obj[0], i );
9973 if ( PyString_Check( s ) )
9974 {
9975 arg2[i] = PyString_AsString( s );
9976 }
9977 else if ( PyUnicode_Check( s ) )
9978 {
9979 // unicode_string is never freed? memory leak here?
9980 unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9981 arg2[i] = PyBytes_AS_STRING( unicode_string );
9982 }
9983 else
9984 {
9985 free( arg2 );
9986 PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9987 return NULL;
9988 }
9989 }
9990 arg2[i] = 0;
9991 }
9992 ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
9993 if (!SWIG_IsOK(ecode3)) {
9994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9995 }
9996 arg3 = (PLINT)(val3);
9997 result = (PLINT)plparseopts(arg1,arg2,arg3);
9998 resultobj = SWIG_From_int((int)(result));
9999 {
10000 if ( arg2 )
10001 free( arg2 );
10002 }
10003 return resultobj;
10004fail:
10005 {
10006 if ( arg2 )
10007 free( arg2 );
10008 }
10009 return NULL;
10010}
10011
10012
10013SWIGINTERN PyObject *_wrap_plpat(PyObject *self, PyObject *args) {
10014 PyObject *resultobj = 0;
10015 PLINT arg1 ;
10016 PLINT *arg2 = 0 ;
10017 PLINT *arg3 = 0 ;
10018 PyArrayObject *tmp1 = NULL ;
10019 PyArrayObject *tmp3 = NULL ;
10020 PyObject *swig_obj[2] ;
10021
10022 (void)self;
10023 if (!SWIG_Python_UnpackTuple(args, "plpat", 2, 2, swig_obj)) SWIG_fail;
10024 {
10025 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10026 if ( tmp1 == NULL )
10027 return NULL;
10028 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10029 arg2 = (PLINT *) PyArray_DATA( tmp1 );
10030 }
10031 {
10032 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10033 if ( tmp3 == NULL )
10034 return NULL;
10035 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10036 {
10037 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10038 return NULL;
10039 }
10040 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10041 }
10042 plpat(arg1,(int const *)arg2,(int const *)arg3);
10043 resultobj = SWIG_Py_Void();
10044 {
10045 Py_CLEAR( tmp1 );
10046 }
10047 {
10048 Py_CLEAR( tmp3 );
10049 }
10050 return resultobj;
10051fail:
10052 {
10053 Py_CLEAR( tmp1 );
10054 }
10055 {
10056 Py_CLEAR( tmp3 );
10057 }
10058 return NULL;
10059}
10060
10061
10062SWIGINTERN PyObject *_wrap_plpath(PyObject *self, PyObject *args) {
10063 PyObject *resultobj = 0;
10064 PLINT arg1 ;
10065 PLFLT arg2 ;
10066 PLFLT arg3 ;
10067 PLFLT arg4 ;
10068 PLFLT arg5 ;
10069 int val1 ;
10070 int ecode1 = 0 ;
10071 double val2 ;
10072 int ecode2 = 0 ;
10073 double val3 ;
10074 int ecode3 = 0 ;
10075 double val4 ;
10076 int ecode4 = 0 ;
10077 double val5 ;
10078 int ecode5 = 0 ;
10079 PyObject *swig_obj[5] ;
10080
10081 (void)self;
10082 if (!SWIG_Python_UnpackTuple(args, "plpath", 5, 5, swig_obj)) SWIG_fail;
10083 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10084 if (!SWIG_IsOK(ecode1)) {
10085 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
10086 }
10087 arg1 = (PLINT)(val1);
10088 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10089 if (!SWIG_IsOK(ecode2)) {
10090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
10091 }
10092 arg2 = (PLFLT)(val2);
10093 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10094 if (!SWIG_IsOK(ecode3)) {
10095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
10096 }
10097 arg3 = (PLFLT)(val3);
10098 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10099 if (!SWIG_IsOK(ecode4)) {
10100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
10101 }
10102 arg4 = (PLFLT)(val4);
10103 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10104 if (!SWIG_IsOK(ecode5)) {
10105 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
10106 }
10107 arg5 = (PLFLT)(val5);
10108 plpath(arg1,arg2,arg3,arg4,arg5);
10109 resultobj = SWIG_Py_Void();
10110 return resultobj;
10111fail:
10112 return NULL;
10113}
10114
10115
10116SWIGINTERN PyObject *_wrap_plpoin(PyObject *self, PyObject *args) {
10117 PyObject *resultobj = 0;
10118 PLINT arg1 ;
10119 PLFLT *arg2 = 0 ;
10120 PLFLT *arg3 = 0 ;
10121 PLINT arg4 ;
10122 PyArrayObject *tmp1 = NULL ;
10123 PyArrayObject *tmp3 = NULL ;
10124 int val4 ;
10125 int ecode4 = 0 ;
10126 PyObject *swig_obj[3] ;
10127
10128 (void)self;
10129 if (!SWIG_Python_UnpackTuple(args, "plpoin", 3, 3, swig_obj)) SWIG_fail;
10130 {
10131 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10132 if ( tmp1 == NULL )
10133 return NULL;
10134 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10135 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10136 }
10137 {
10138 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10139 if ( tmp3 == NULL )
10140 return NULL;
10141 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10142 {
10143 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10144 return NULL;
10145 }
10146 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10147 }
10148 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
10149 if (!SWIG_IsOK(ecode4)) {
10150 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
10151 }
10152 arg4 = (PLINT)(val4);
10153 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
10154 resultobj = SWIG_Py_Void();
10155 {
10156 Py_CLEAR( tmp1 );
10157 }
10158 {
10159 Py_CLEAR( tmp3 );
10160 }
10161 return resultobj;
10162fail:
10163 {
10164 Py_CLEAR( tmp1 );
10165 }
10166 {
10167 Py_CLEAR( tmp3 );
10168 }
10169 return NULL;
10170}
10171
10172
10173SWIGINTERN PyObject *_wrap_plpoin3(PyObject *self, PyObject *args) {
10174 PyObject *resultobj = 0;
10175 PLINT arg1 ;
10176 PLFLT *arg2 = 0 ;
10177 PLFLT *arg3 = 0 ;
10178 PLFLT *arg4 = 0 ;
10179 PLINT arg5 ;
10180 PyArrayObject *tmp1 = NULL ;
10181 PyArrayObject *tmp3 = NULL ;
10182 PyArrayObject *tmp4 = NULL ;
10183 int val5 ;
10184 int ecode5 = 0 ;
10185 PyObject *swig_obj[4] ;
10186
10187 (void)self;
10188 if (!SWIG_Python_UnpackTuple(args, "plpoin3", 4, 4, swig_obj)) SWIG_fail;
10189 {
10190 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10191 if ( tmp1 == NULL )
10192 return NULL;
10193 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10194 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10195 }
10196 {
10197 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10198 if ( tmp3 == NULL )
10199 return NULL;
10200 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10201 {
10202 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10203 return NULL;
10204 }
10205 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10206 }
10207 {
10208 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10209 if ( tmp4 == NULL )
10210 return NULL;
10211 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10212 {
10213 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10214 return NULL;
10215 }
10216 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10217 }
10218 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
10219 if (!SWIG_IsOK(ecode5)) {
10220 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
10221 }
10222 arg5 = (PLINT)(val5);
10223 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
10224 resultobj = SWIG_Py_Void();
10225 {
10226 Py_CLEAR( tmp1 );
10227 }
10228 {
10229 Py_CLEAR( tmp3 );
10230 }
10231 {
10232 Py_CLEAR( tmp4 );
10233 }
10234 return resultobj;
10235fail:
10236 {
10237 Py_CLEAR( tmp1 );
10238 }
10239 {
10240 Py_CLEAR( tmp3 );
10241 }
10242 {
10243 Py_CLEAR( tmp4 );
10244 }
10245 return NULL;
10246}
10247
10248
10249SWIGINTERN PyObject *_wrap_plpoly3(PyObject *self, PyObject *args) {
10250 PyObject *resultobj = 0;
10251 PLINT arg1 ;
10252 PLFLT *arg2 = 0 ;
10253 PLFLT *arg3 = 0 ;
10254 PLFLT *arg4 = 0 ;
10255 PLBOOL *arg5 = 0 ;
10256 PLBOOL arg6 ;
10257 PyArrayObject *tmp1 = NULL ;
10258 PyArrayObject *tmp3 = NULL ;
10259 PyArrayObject *tmp4 = NULL ;
10260 PyArrayObject *tmp5 = NULL ;
10261 int val6 ;
10262 int ecode6 = 0 ;
10263 PyObject *swig_obj[5] ;
10264
10265 (void)self;
10266 if (!SWIG_Python_UnpackTuple(args, "plpoly3", 5, 5, swig_obj)) SWIG_fail;
10267 {
10268 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10269 if ( tmp1 == NULL )
10270 return NULL;
10271 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10272 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10273 }
10274 {
10275 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10276 if ( tmp3 == NULL )
10277 return NULL;
10278 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10279 {
10280 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10281 return NULL;
10282 }
10283 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10284 }
10285 {
10286 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10287 if ( tmp4 == NULL )
10288 return NULL;
10289 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10290 {
10291 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10292 return NULL;
10293 }
10294 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10295 }
10296 {
10297 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[3], NPY_PLINT, 1, 1 );
10298 if ( tmp5 == NULL )
10299 return NULL;
10300 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10301 {
10302 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10303 return NULL;
10304 }
10305 arg5 = (PLINT *) PyArray_DATA( tmp5 );
10306 }
10307 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
10308 if (!SWIG_IsOK(ecode6)) {
10309 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10310 }
10311 arg6 = (PLBOOL)(val6);
10312 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10313 resultobj = SWIG_Py_Void();
10314 {
10315 Py_CLEAR( tmp1 );
10316 }
10317 {
10318 Py_CLEAR( tmp3 );
10319 }
10320 {
10321 Py_CLEAR( tmp4 );
10322 }
10323 {
10324 Py_CLEAR( tmp5 );
10325 }
10326 return resultobj;
10327fail:
10328 {
10329 Py_CLEAR( tmp1 );
10330 }
10331 {
10332 Py_CLEAR( tmp3 );
10333 }
10334 {
10335 Py_CLEAR( tmp4 );
10336 }
10337 {
10338 Py_CLEAR( tmp5 );
10339 }
10340 return NULL;
10341}
10342
10343
10344SWIGINTERN PyObject *_wrap_plprec(PyObject *self, PyObject *args) {
10345 PyObject *resultobj = 0;
10346 PLINT arg1 ;
10347 PLINT arg2 ;
10348 int val1 ;
10349 int ecode1 = 0 ;
10350 int val2 ;
10351 int ecode2 = 0 ;
10352 PyObject *swig_obj[2] ;
10353
10354 (void)self;
10355 if (!SWIG_Python_UnpackTuple(args, "plprec", 2, 2, swig_obj)) SWIG_fail;
10356 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10357 if (!SWIG_IsOK(ecode1)) {
10358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10359 }
10360 arg1 = (PLINT)(val1);
10361 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10362 if (!SWIG_IsOK(ecode2)) {
10363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10364 }
10365 arg2 = (PLINT)(val2);
10366 plprec(arg1,arg2);
10367 resultobj = SWIG_Py_Void();
10368 return resultobj;
10369fail:
10370 return NULL;
10371}
10372
10373
10374SWIGINTERN PyObject *_wrap_plpsty(PyObject *self, PyObject *args) {
10375 PyObject *resultobj = 0;
10376 PLINT arg1 ;
10377 int val1 ;
10378 int ecode1 = 0 ;
10379 PyObject *swig_obj[1] ;
10380
10381 (void)self;
10382 if (!args) SWIG_fail;
10383 swig_obj[0] = args;
10384 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10385 if (!SWIG_IsOK(ecode1)) {
10386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10387 }
10388 arg1 = (PLINT)(val1);
10389 plpsty(arg1);
10390 resultobj = SWIG_Py_Void();
10391 return resultobj;
10392fail:
10393 return NULL;
10394}
10395
10396
10397SWIGINTERN PyObject *_wrap_plptex(PyObject *self, PyObject *args) {
10398 PyObject *resultobj = 0;
10399 PLFLT arg1 ;
10400 PLFLT arg2 ;
10401 PLFLT arg3 ;
10402 PLFLT arg4 ;
10403 PLFLT arg5 ;
10404 char *arg6 = 0 ;
10405 double val1 ;
10406 int ecode1 = 0 ;
10407 double val2 ;
10408 int ecode2 = 0 ;
10409 double val3 ;
10410 int ecode3 = 0 ;
10411 double val4 ;
10412 int ecode4 = 0 ;
10413 double val5 ;
10414 int ecode5 = 0 ;
10415 int res6 ;
10416 char *buf6 = 0 ;
10417 int alloc6 = 0 ;
10418 PyObject *swig_obj[6] ;
10419
10420 (void)self;
10421 if (!SWIG_Python_UnpackTuple(args, "plptex", 6, 6, swig_obj)) SWIG_fail;
10422 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10423 if (!SWIG_IsOK(ecode1)) {
10424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10425 }
10426 arg1 = (PLFLT)(val1);
10427 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10428 if (!SWIG_IsOK(ecode2)) {
10429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10430 }
10431 arg2 = (PLFLT)(val2);
10432 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10433 if (!SWIG_IsOK(ecode3)) {
10434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10435 }
10436 arg3 = (PLFLT)(val3);
10437 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10438 if (!SWIG_IsOK(ecode4)) {
10439 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10440 }
10441 arg4 = (PLFLT)(val4);
10442 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10443 if (!SWIG_IsOK(ecode5)) {
10444 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10445 }
10446 arg5 = (PLFLT)(val5);
10447 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
10448 if (!SWIG_IsOK(res6)) {
10449 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10450 }
10451 arg6 = (char *)(buf6);
10452 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10453 resultobj = SWIG_Py_Void();
10454 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10455 return resultobj;
10456fail:
10457 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10458 return NULL;
10459}
10460
10461
10462SWIGINTERN PyObject *_wrap_plptex3(PyObject *self, PyObject *args) {
10463 PyObject *resultobj = 0;
10464 PLFLT arg1 ;
10465 PLFLT arg2 ;
10466 PLFLT arg3 ;
10467 PLFLT arg4 ;
10468 PLFLT arg5 ;
10469 PLFLT arg6 ;
10470 PLFLT arg7 ;
10471 PLFLT arg8 ;
10472 PLFLT arg9 ;
10473 PLFLT arg10 ;
10474 char *arg11 = 0 ;
10475 double val1 ;
10476 int ecode1 = 0 ;
10477 double val2 ;
10478 int ecode2 = 0 ;
10479 double val3 ;
10480 int ecode3 = 0 ;
10481 double val4 ;
10482 int ecode4 = 0 ;
10483 double val5 ;
10484 int ecode5 = 0 ;
10485 double val6 ;
10486 int ecode6 = 0 ;
10487 double val7 ;
10488 int ecode7 = 0 ;
10489 double val8 ;
10490 int ecode8 = 0 ;
10491 double val9 ;
10492 int ecode9 = 0 ;
10493 double val10 ;
10494 int ecode10 = 0 ;
10495 int res11 ;
10496 char *buf11 = 0 ;
10497 int alloc11 = 0 ;
10498 PyObject *swig_obj[11] ;
10499
10500 (void)self;
10501 if (!SWIG_Python_UnpackTuple(args, "plptex3", 11, 11, swig_obj)) SWIG_fail;
10502 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10503 if (!SWIG_IsOK(ecode1)) {
10504 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10505 }
10506 arg1 = (PLFLT)(val1);
10507 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10508 if (!SWIG_IsOK(ecode2)) {
10509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10510 }
10511 arg2 = (PLFLT)(val2);
10512 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10513 if (!SWIG_IsOK(ecode3)) {
10514 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10515 }
10516 arg3 = (PLFLT)(val3);
10517 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10518 if (!SWIG_IsOK(ecode4)) {
10519 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10520 }
10521 arg4 = (PLFLT)(val4);
10522 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10523 if (!SWIG_IsOK(ecode5)) {
10524 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10525 }
10526 arg5 = (PLFLT)(val5);
10527 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
10528 if (!SWIG_IsOK(ecode6)) {
10529 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10530 }
10531 arg6 = (PLFLT)(val6);
10532 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
10533 if (!SWIG_IsOK(ecode7)) {
10534 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10535 }
10536 arg7 = (PLFLT)(val7);
10537 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
10538 if (!SWIG_IsOK(ecode8)) {
10539 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10540 }
10541 arg8 = (PLFLT)(val8);
10542 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
10543 if (!SWIG_IsOK(ecode9)) {
10544 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10545 }
10546 arg9 = (PLFLT)(val9);
10547 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
10548 if (!SWIG_IsOK(ecode10)) {
10549 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10550 }
10551 arg10 = (PLFLT)(val10);
10552 res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
10553 if (!SWIG_IsOK(res11)) {
10554 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10555 }
10556 arg11 = (char *)(buf11);
10557 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10558 resultobj = SWIG_Py_Void();
10559 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10560 return resultobj;
10561fail:
10562 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10563 return NULL;
10564}
10565
10566
10567SWIGINTERN PyObject *_wrap_plrandd(PyObject *self, PyObject *args) {
10568 PyObject *resultobj = 0;
10569 PLFLT result;
10570
10571 (void)self;
10572 if (!SWIG_Python_UnpackTuple(args, "plrandd", 0, 0, 0)) SWIG_fail;
10573 result = (PLFLT)plrandd();
10574 resultobj = SWIG_From_double((double)(result));
10575 return resultobj;
10576fail:
10577 return NULL;
10578}
10579
10580
10581SWIGINTERN PyObject *_wrap_plreplot(PyObject *self, PyObject *args) {
10582 PyObject *resultobj = 0;
10583
10584 (void)self;
10585 if (!SWIG_Python_UnpackTuple(args, "plreplot", 0, 0, 0)) SWIG_fail;
10586 plreplot();
10587 resultobj = SWIG_Py_Void();
10588 return resultobj;
10589fail:
10590 return NULL;
10591}
10592
10593
10594SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *self, PyObject *args) {
10595 PyObject *resultobj = 0;
10596 PLFLT arg1 ;
10597 PLFLT arg2 ;
10598 PLFLT arg3 ;
10599 PLFLT *arg4 = 0 ;
10600 PLFLT *arg5 = 0 ;
10601 PLFLT *arg6 = 0 ;
10602 double val1 ;
10603 int ecode1 = 0 ;
10604 double val2 ;
10605 int ecode2 = 0 ;
10606 double val3 ;
10607 int ecode3 = 0 ;
10608 PLFLT temp4 ;
10609 int res4 = SWIG_TMPOBJ ;
10610 PLFLT temp5 ;
10611 int res5 = SWIG_TMPOBJ ;
10612 PLFLT temp6 ;
10613 int res6 = SWIG_TMPOBJ ;
10614 PyObject *swig_obj[3] ;
10615
10616 arg4 = &temp4;
10617 arg5 = &temp5;
10618 arg6 = &temp6;
10619 (void)self;
10620 if (!SWIG_Python_UnpackTuple(args, "plrgbhls", 3, 3, swig_obj)) SWIG_fail;
10621 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10622 if (!SWIG_IsOK(ecode1)) {
10623 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10624 }
10625 arg1 = (PLFLT)(val1);
10626 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10627 if (!SWIG_IsOK(ecode2)) {
10628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10629 }
10630 arg2 = (PLFLT)(val2);
10631 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10632 if (!SWIG_IsOK(ecode3)) {
10633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10634 }
10635 arg3 = (PLFLT)(val3);
10636 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10637 resultobj = SWIG_Py_Void();
10638 if (SWIG_IsTmpObj(res4)) {
10639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
10640 } else {
10641 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
10643 }
10644 if (SWIG_IsTmpObj(res5)) {
10645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
10646 } else {
10647 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10648 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
10649 }
10650 if (SWIG_IsTmpObj(res6)) {
10651 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 1);
10652 } else {
10653 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10654 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 1);
10655 }
10656 return resultobj;
10657fail:
10658 return NULL;
10659}
10660
10661
10662SWIGINTERN PyObject *_wrap_plschr(PyObject *self, PyObject *args) {
10663 PyObject *resultobj = 0;
10664 PLFLT arg1 ;
10665 PLFLT arg2 ;
10666 double val1 ;
10667 int ecode1 = 0 ;
10668 double val2 ;
10669 int ecode2 = 0 ;
10670 PyObject *swig_obj[2] ;
10671
10672 (void)self;
10673 if (!SWIG_Python_UnpackTuple(args, "plschr", 2, 2, swig_obj)) SWIG_fail;
10674 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10675 if (!SWIG_IsOK(ecode1)) {
10676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10677 }
10678 arg1 = (PLFLT)(val1);
10679 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10680 if (!SWIG_IsOK(ecode2)) {
10681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10682 }
10683 arg2 = (PLFLT)(val2);
10684 plschr(arg1,arg2);
10685 resultobj = SWIG_Py_Void();
10686 return resultobj;
10687fail:
10688 return NULL;
10689}
10690
10691
10692SWIGINTERN PyObject *_wrap_plscmap0(PyObject *self, PyObject *args) {
10693 PyObject *resultobj = 0;
10694 PLINT *arg1 = 0 ;
10695 PLINT *arg2 = 0 ;
10696 PLINT *arg3 = 0 ;
10697 PLINT arg4 ;
10698 PyArrayObject *tmp1 = NULL ;
10699 PyArrayObject *tmp2 = NULL ;
10700 PyArrayObject *tmp3 = NULL ;
10701 PyObject *swig_obj[3] ;
10702
10703 (void)self;
10704 if (!SWIG_Python_UnpackTuple(args, "plscmap0", 3, 3, swig_obj)) SWIG_fail;
10705 {
10706 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10707 if ( tmp1 == NULL )
10708 return NULL;
10709 Alen = PyArray_DIMS( tmp1 )[0];
10710 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10711 }
10712 {
10713 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10714 if ( tmp2 == NULL )
10715 return NULL;
10716 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10717 {
10718 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10719 return NULL;
10720 }
10721 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10722 }
10723 {
10724 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10725 if ( tmp3 == NULL )
10726 return NULL;
10727 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10728 {
10729 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10730 return NULL;
10731 }
10732 arg4 = PyArray_DIMS( tmp3 )[0];
10733 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10734 }
10735 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10736 resultobj = SWIG_Py_Void();
10737 {
10738 Py_CLEAR( tmp1 );
10739 }
10740 {
10741 Py_CLEAR( tmp2 );
10742 }
10743 {
10744 Py_CLEAR( tmp3 );
10745 }
10746 return resultobj;
10747fail:
10748 {
10749 Py_CLEAR( tmp1 );
10750 }
10751 {
10752 Py_CLEAR( tmp2 );
10753 }
10754 {
10755 Py_CLEAR( tmp3 );
10756 }
10757 return NULL;
10758}
10759
10760
10761SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *self, PyObject *args) {
10762 PyObject *resultobj = 0;
10763 PLINT *arg1 = 0 ;
10764 PLINT *arg2 = 0 ;
10765 PLINT *arg3 = 0 ;
10766 PLFLT *arg4 = 0 ;
10767 PLINT arg5 ;
10768 PyArrayObject *tmp1 = NULL ;
10769 PyArrayObject *tmp2 = NULL ;
10770 PyArrayObject *tmp3 = NULL ;
10771 PyArrayObject *tmp4 = NULL ;
10772 PyObject *swig_obj[4] ;
10773
10774 (void)self;
10775 if (!SWIG_Python_UnpackTuple(args, "plscmap0a", 4, 4, swig_obj)) SWIG_fail;
10776 {
10777 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10778 if ( tmp1 == NULL )
10779 return NULL;
10780 Alen = PyArray_DIMS( tmp1 )[0];
10781 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10782 }
10783 {
10784 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10785 if ( tmp2 == NULL )
10786 return NULL;
10787 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10788 {
10789 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10790 return NULL;
10791 }
10792 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10793 }
10794 {
10795 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10796 if ( tmp3 == NULL )
10797 return NULL;
10798 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10799 {
10800 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10801 return NULL;
10802 }
10803 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10804 }
10805 {
10806 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10807 if ( tmp4 == NULL )
10808 return NULL;
10809 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10810 {
10811 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10812 return NULL;
10813 }
10814 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10815 arg5 = PyArray_DIMS( tmp4 )[0];
10816 }
10817 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10818 resultobj = SWIG_Py_Void();
10819 {
10820 Py_CLEAR( tmp1 );
10821 }
10822 {
10823 Py_CLEAR( tmp2 );
10824 }
10825 {
10826 Py_CLEAR( tmp3 );
10827 }
10828 {
10829 Py_CLEAR( tmp4 );
10830 }
10831 return resultobj;
10832fail:
10833 {
10834 Py_CLEAR( tmp1 );
10835 }
10836 {
10837 Py_CLEAR( tmp2 );
10838 }
10839 {
10840 Py_CLEAR( tmp3 );
10841 }
10842 {
10843 Py_CLEAR( tmp4 );
10844 }
10845 return NULL;
10846}
10847
10848
10849SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *self, PyObject *args) {
10850 PyObject *resultobj = 0;
10851 PLINT arg1 ;
10852 int val1 ;
10853 int ecode1 = 0 ;
10854 PyObject *swig_obj[1] ;
10855
10856 (void)self;
10857 if (!args) SWIG_fail;
10858 swig_obj[0] = args;
10859 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10860 if (!SWIG_IsOK(ecode1)) {
10861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10862 }
10863 arg1 = (PLINT)(val1);
10864 plscmap0n(arg1);
10865 resultobj = SWIG_Py_Void();
10866 return resultobj;
10867fail:
10868 return NULL;
10869}
10870
10871
10872SWIGINTERN PyObject *_wrap_plscmap1(PyObject *self, PyObject *args) {
10873 PyObject *resultobj = 0;
10874 PLINT *arg1 = 0 ;
10875 PLINT *arg2 = 0 ;
10876 PLINT *arg3 = 0 ;
10877 PLINT arg4 ;
10878 PyArrayObject *tmp1 = NULL ;
10879 PyArrayObject *tmp2 = NULL ;
10880 PyArrayObject *tmp3 = NULL ;
10881 PyObject *swig_obj[3] ;
10882
10883 (void)self;
10884 if (!SWIG_Python_UnpackTuple(args, "plscmap1", 3, 3, swig_obj)) SWIG_fail;
10885 {
10886 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10887 if ( tmp1 == NULL )
10888 return NULL;
10889 Alen = PyArray_DIMS( tmp1 )[0];
10890 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10891 }
10892 {
10893 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10894 if ( tmp2 == NULL )
10895 return NULL;
10896 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10897 {
10898 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10899 return NULL;
10900 }
10901 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10902 }
10903 {
10904 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10905 if ( tmp3 == NULL )
10906 return NULL;
10907 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10908 {
10909 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10910 return NULL;
10911 }
10912 arg4 = PyArray_DIMS( tmp3 )[0];
10913 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10914 }
10915 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10916 resultobj = SWIG_Py_Void();
10917 {
10918 Py_CLEAR( tmp1 );
10919 }
10920 {
10921 Py_CLEAR( tmp2 );
10922 }
10923 {
10924 Py_CLEAR( tmp3 );
10925 }
10926 return resultobj;
10927fail:
10928 {
10929 Py_CLEAR( tmp1 );
10930 }
10931 {
10932 Py_CLEAR( tmp2 );
10933 }
10934 {
10935 Py_CLEAR( tmp3 );
10936 }
10937 return NULL;
10938}
10939
10940
10941SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *self, PyObject *args) {
10942 PyObject *resultobj = 0;
10943 PLINT *arg1 = 0 ;
10944 PLINT *arg2 = 0 ;
10945 PLINT *arg3 = 0 ;
10946 PLFLT *arg4 = 0 ;
10947 PLINT arg5 ;
10948 PyArrayObject *tmp1 = NULL ;
10949 PyArrayObject *tmp2 = NULL ;
10950 PyArrayObject *tmp3 = NULL ;
10951 PyArrayObject *tmp4 = NULL ;
10952 PyObject *swig_obj[4] ;
10953
10954 (void)self;
10955 if (!SWIG_Python_UnpackTuple(args, "plscmap1a", 4, 4, swig_obj)) SWIG_fail;
10956 {
10957 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10958 if ( tmp1 == NULL )
10959 return NULL;
10960 Alen = PyArray_DIMS( tmp1 )[0];
10961 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10962 }
10963 {
10964 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10965 if ( tmp2 == NULL )
10966 return NULL;
10967 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10968 {
10969 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10970 return NULL;
10971 }
10972 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10973 }
10974 {
10975 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10976 if ( tmp3 == NULL )
10977 return NULL;
10978 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10979 {
10980 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10981 return NULL;
10982 }
10983 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10984 }
10985 {
10986 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10987 if ( tmp4 == NULL )
10988 return NULL;
10989 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10990 {
10991 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10992 return NULL;
10993 }
10994 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10995 arg5 = PyArray_DIMS( tmp4 )[0];
10996 }
10997 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10998 resultobj = SWIG_Py_Void();
10999 {
11000 Py_CLEAR( tmp1 );
11001 }
11002 {
11003 Py_CLEAR( tmp2 );
11004 }
11005 {
11006 Py_CLEAR( tmp3 );
11007 }
11008 {
11009 Py_CLEAR( tmp4 );
11010 }
11011 return resultobj;
11012fail:
11013 {
11014 Py_CLEAR( tmp1 );
11015 }
11016 {
11017 Py_CLEAR( tmp2 );
11018 }
11019 {
11020 Py_CLEAR( tmp3 );
11021 }
11022 {
11023 Py_CLEAR( tmp4 );
11024 }
11025 return NULL;
11026}
11027
11028
11029SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *self, PyObject *args) {
11030 PyObject *resultobj = 0;
11031 PLBOOL arg1 ;
11032 PLINT arg2 ;
11033 PLFLT *arg3 = 0 ;
11034 PLFLT *arg4 = 0 ;
11035 PLFLT *arg5 = 0 ;
11036 PLFLT *arg6 = 0 ;
11037 PLBOOL *arg7 = 0 ;
11038 int val1 ;
11039 int ecode1 = 0 ;
11040 PyArrayObject *tmp2 = NULL ;
11041 PyArrayObject *tmp4 = NULL ;
11042 PyArrayObject *tmp5 = NULL ;
11043 PyArrayObject *tmp6 = NULL ;
11044 PyArrayObject *tmp7 = NULL ;
11045 PyObject *swig_obj[6] ;
11046
11047 (void)self;
11048 if (!SWIG_Python_UnpackTuple(args, "plscmap1l", 6, 6, swig_obj)) SWIG_fail;
11049 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11050 if (!SWIG_IsOK(ecode1)) {
11051 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
11052 }
11053 arg1 = (PLBOOL)(val1);
11054 {
11055 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11056 if ( tmp2 == NULL )
11057 return NULL;
11058 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11059 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11060 }
11061 {
11062 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11063 if ( tmp4 == NULL )
11064 return NULL;
11065 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11066 {
11067 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11068 return NULL;
11069 }
11070 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11071 }
11072 {
11073 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11074 if ( tmp5 == NULL )
11075 return NULL;
11076 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11077 {
11078 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11079 return NULL;
11080 }
11081 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11082 }
11083 {
11084 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11085 if ( tmp6 == NULL )
11086 return NULL;
11087 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11088 {
11089 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11090 return NULL;
11091 }
11092 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11093 }
11094 {
11095 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[5], NPY_PLINT, 1, 1 );
11096 if ( tmp7 == NULL )
11097 return NULL;
11098 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
11099 {
11100 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11101 return NULL;
11102 }
11103 arg7 = (PLINT *) PyArray_DATA( tmp7 );
11104 }
11105 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
11106 resultobj = SWIG_Py_Void();
11107 {
11108 Py_CLEAR( tmp2 );
11109 }
11110 {
11111 Py_CLEAR( tmp4 );
11112 }
11113 {
11114 Py_CLEAR( tmp5 );
11115 }
11116 {
11117 Py_CLEAR( tmp6 );
11118 }
11119 {
11120 Py_CLEAR( tmp7 );
11121 }
11122 return resultobj;
11123fail:
11124 {
11125 Py_CLEAR( tmp2 );
11126 }
11127 {
11128 Py_CLEAR( tmp4 );
11129 }
11130 {
11131 Py_CLEAR( tmp5 );
11132 }
11133 {
11134 Py_CLEAR( tmp6 );
11135 }
11136 {
11137 Py_CLEAR( tmp7 );
11138 }
11139 return NULL;
11140}
11141
11142
11143SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *self, PyObject *args) {
11144 PyObject *resultobj = 0;
11145 PLBOOL arg1 ;
11146 PLINT arg2 ;
11147 PLFLT *arg3 = 0 ;
11148 PLFLT *arg4 = 0 ;
11149 PLFLT *arg5 = 0 ;
11150 PLFLT *arg6 = 0 ;
11151 PLFLT *arg7 = 0 ;
11152 PLBOOL *arg8 = 0 ;
11153 int val1 ;
11154 int ecode1 = 0 ;
11155 PyArrayObject *tmp2 = NULL ;
11156 PyArrayObject *tmp4 = NULL ;
11157 PyArrayObject *tmp5 = NULL ;
11158 PyArrayObject *tmp6 = NULL ;
11159 PyArrayObject *tmp7 = NULL ;
11160 PyArrayObject *tmp8 = NULL ;
11161 PyObject *swig_obj[7] ;
11162
11163 (void)self;
11164 if (!SWIG_Python_UnpackTuple(args, "plscmap1la", 7, 7, swig_obj)) SWIG_fail;
11165 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11166 if (!SWIG_IsOK(ecode1)) {
11167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
11168 }
11169 arg1 = (PLBOOL)(val1);
11170 {
11171 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11172 if ( tmp2 == NULL )
11173 return NULL;
11174 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11175 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11176 }
11177 {
11178 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11179 if ( tmp4 == NULL )
11180 return NULL;
11181 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11182 {
11183 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11184 return NULL;
11185 }
11186 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11187 }
11188 {
11189 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11190 if ( tmp5 == NULL )
11191 return NULL;
11192 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11193 {
11194 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11195 return NULL;
11196 }
11197 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11198 }
11199 {
11200 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11201 if ( tmp6 == NULL )
11202 return NULL;
11203 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11204 {
11205 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11206 return NULL;
11207 }
11208 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11209 }
11210 {
11211 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
11212 if ( tmp7 == NULL )
11213 return NULL;
11214 if ( PyArray_DIMS( tmp7 )[0] != Alen )
11215 {
11216 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11217 return NULL;
11218 }
11219 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
11220 }
11221 {
11222 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
11223 if ( tmp8 == NULL )
11224 return NULL;
11225 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
11226 {
11227 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11228 return NULL;
11229 }
11230 arg8 = (PLINT *) PyArray_DATA( tmp8 );
11231 }
11232 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
11233 resultobj = SWIG_Py_Void();
11234 {
11235 Py_CLEAR( tmp2 );
11236 }
11237 {
11238 Py_CLEAR( tmp4 );
11239 }
11240 {
11241 Py_CLEAR( tmp5 );
11242 }
11243 {
11244 Py_CLEAR( tmp6 );
11245 }
11246 {
11247 Py_CLEAR( tmp7 );
11248 }
11249 {
11250 Py_CLEAR( tmp8 );
11251 }
11252 return resultobj;
11253fail:
11254 {
11255 Py_CLEAR( tmp2 );
11256 }
11257 {
11258 Py_CLEAR( tmp4 );
11259 }
11260 {
11261 Py_CLEAR( tmp5 );
11262 }
11263 {
11264 Py_CLEAR( tmp6 );
11265 }
11266 {
11267 Py_CLEAR( tmp7 );
11268 }
11269 {
11270 Py_CLEAR( tmp8 );
11271 }
11272 return NULL;
11273}
11274
11275
11276SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *self, PyObject *args) {
11277 PyObject *resultobj = 0;
11278 PLINT arg1 ;
11279 int val1 ;
11280 int ecode1 = 0 ;
11281 PyObject *swig_obj[1] ;
11282
11283 (void)self;
11284 if (!args) SWIG_fail;
11285 swig_obj[0] = args;
11286 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11287 if (!SWIG_IsOK(ecode1)) {
11288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11289 }
11290 arg1 = (PLINT)(val1);
11291 plscmap1n(arg1);
11292 resultobj = SWIG_Py_Void();
11293 return resultobj;
11294fail:
11295 return NULL;
11296}
11297
11298
11299SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *self, PyObject *args) {
11300 PyObject *resultobj = 0;
11301 PLFLT arg1 ;
11302 PLFLT arg2 ;
11303 double val1 ;
11304 int ecode1 = 0 ;
11305 double val2 ;
11306 int ecode2 = 0 ;
11307 PyObject *swig_obj[2] ;
11308
11309 (void)self;
11310 if (!SWIG_Python_UnpackTuple(args, "plscmap1_range", 2, 2, swig_obj)) SWIG_fail;
11311 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11312 if (!SWIG_IsOK(ecode1)) {
11313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11314 }
11315 arg1 = (PLFLT)(val1);
11316 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11317 if (!SWIG_IsOK(ecode2)) {
11318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11319 }
11320 arg2 = (PLFLT)(val2);
11321 plscmap1_range(arg1,arg2);
11322 resultobj = SWIG_Py_Void();
11323 return resultobj;
11324fail:
11325 return NULL;
11326}
11327
11328
11329SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *self, PyObject *args) {
11330 PyObject *resultobj = 0;
11331 PLFLT *arg1 = 0 ;
11332 PLFLT *arg2 = 0 ;
11333 PLFLT temp1 ;
11334 int res1 = SWIG_TMPOBJ ;
11335 PLFLT temp2 ;
11336 int res2 = SWIG_TMPOBJ ;
11337
11338 arg1 = &temp1;
11339 arg2 = &temp2;
11340 (void)self;
11341 if (!SWIG_Python_UnpackTuple(args, "plgcmap1_range", 0, 0, 0)) SWIG_fail;
11342 plgcmap1_range(arg1,arg2);
11343 resultobj = SWIG_Py_Void();
11344 if (SWIG_IsTmpObj(res1)) {
11345 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
11346 } else {
11347 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
11349 }
11350 if (SWIG_IsTmpObj(res2)) {
11351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
11352 } else {
11353 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
11355 }
11356 return resultobj;
11357fail:
11358 return NULL;
11359}
11360
11361
11362SWIGINTERN PyObject *_wrap_plscol0(PyObject *self, PyObject *args) {
11363 PyObject *resultobj = 0;
11364 PLINT arg1 ;
11365 PLINT arg2 ;
11366 PLINT arg3 ;
11367 PLINT arg4 ;
11368 int val1 ;
11369 int ecode1 = 0 ;
11370 int val2 ;
11371 int ecode2 = 0 ;
11372 int val3 ;
11373 int ecode3 = 0 ;
11374 int val4 ;
11375 int ecode4 = 0 ;
11376 PyObject *swig_obj[4] ;
11377
11378 (void)self;
11379 if (!SWIG_Python_UnpackTuple(args, "plscol0", 4, 4, swig_obj)) SWIG_fail;
11380 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11381 if (!SWIG_IsOK(ecode1)) {
11382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11383 }
11384 arg1 = (PLINT)(val1);
11385 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11386 if (!SWIG_IsOK(ecode2)) {
11387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11388 }
11389 arg2 = (PLINT)(val2);
11390 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11391 if (!SWIG_IsOK(ecode3)) {
11392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11393 }
11394 arg3 = (PLINT)(val3);
11395 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11396 if (!SWIG_IsOK(ecode4)) {
11397 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11398 }
11399 arg4 = (PLINT)(val4);
11400 plscol0(arg1,arg2,arg3,arg4);
11401 resultobj = SWIG_Py_Void();
11402 return resultobj;
11403fail:
11404 return NULL;
11405}
11406
11407
11408SWIGINTERN PyObject *_wrap_plscol0a(PyObject *self, PyObject *args) {
11409 PyObject *resultobj = 0;
11410 PLINT arg1 ;
11411 PLINT arg2 ;
11412 PLINT arg3 ;
11413 PLINT arg4 ;
11414 PLFLT arg5 ;
11415 int val1 ;
11416 int ecode1 = 0 ;
11417 int val2 ;
11418 int ecode2 = 0 ;
11419 int val3 ;
11420 int ecode3 = 0 ;
11421 int val4 ;
11422 int ecode4 = 0 ;
11423 double val5 ;
11424 int ecode5 = 0 ;
11425 PyObject *swig_obj[5] ;
11426
11427 (void)self;
11428 if (!SWIG_Python_UnpackTuple(args, "plscol0a", 5, 5, swig_obj)) SWIG_fail;
11429 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11430 if (!SWIG_IsOK(ecode1)) {
11431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11432 }
11433 arg1 = (PLINT)(val1);
11434 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11435 if (!SWIG_IsOK(ecode2)) {
11436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11437 }
11438 arg2 = (PLINT)(val2);
11439 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11440 if (!SWIG_IsOK(ecode3)) {
11441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11442 }
11443 arg3 = (PLINT)(val3);
11444 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11445 if (!SWIG_IsOK(ecode4)) {
11446 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11447 }
11448 arg4 = (PLINT)(val4);
11449 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11450 if (!SWIG_IsOK(ecode5)) {
11451 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11452 }
11453 arg5 = (PLFLT)(val5);
11454 plscol0a(arg1,arg2,arg3,arg4,arg5);
11455 resultobj = SWIG_Py_Void();
11456 return resultobj;
11457fail:
11458 return NULL;
11459}
11460
11461
11462SWIGINTERN PyObject *_wrap_plscolbg(PyObject *self, PyObject *args) {
11463 PyObject *resultobj = 0;
11464 PLINT arg1 ;
11465 PLINT arg2 ;
11466 PLINT arg3 ;
11467 int val1 ;
11468 int ecode1 = 0 ;
11469 int val2 ;
11470 int ecode2 = 0 ;
11471 int val3 ;
11472 int ecode3 = 0 ;
11473 PyObject *swig_obj[3] ;
11474
11475 (void)self;
11476 if (!SWIG_Python_UnpackTuple(args, "plscolbg", 3, 3, swig_obj)) SWIG_fail;
11477 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11478 if (!SWIG_IsOK(ecode1)) {
11479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11480 }
11481 arg1 = (PLINT)(val1);
11482 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11483 if (!SWIG_IsOK(ecode2)) {
11484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11485 }
11486 arg2 = (PLINT)(val2);
11487 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11488 if (!SWIG_IsOK(ecode3)) {
11489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11490 }
11491 arg3 = (PLINT)(val3);
11492 plscolbg(arg1,arg2,arg3);
11493 resultobj = SWIG_Py_Void();
11494 return resultobj;
11495fail:
11496 return NULL;
11497}
11498
11499
11500SWIGINTERN PyObject *_wrap_plscolbga(PyObject *self, PyObject *args) {
11501 PyObject *resultobj = 0;
11502 PLINT arg1 ;
11503 PLINT arg2 ;
11504 PLINT arg3 ;
11505 PLFLT arg4 ;
11506 int val1 ;
11507 int ecode1 = 0 ;
11508 int val2 ;
11509 int ecode2 = 0 ;
11510 int val3 ;
11511 int ecode3 = 0 ;
11512 double val4 ;
11513 int ecode4 = 0 ;
11514 PyObject *swig_obj[4] ;
11515
11516 (void)self;
11517 if (!SWIG_Python_UnpackTuple(args, "plscolbga", 4, 4, swig_obj)) SWIG_fail;
11518 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11519 if (!SWIG_IsOK(ecode1)) {
11520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11521 }
11522 arg1 = (PLINT)(val1);
11523 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11524 if (!SWIG_IsOK(ecode2)) {
11525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11526 }
11527 arg2 = (PLINT)(val2);
11528 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11529 if (!SWIG_IsOK(ecode3)) {
11530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11531 }
11532 arg3 = (PLINT)(val3);
11533 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11534 if (!SWIG_IsOK(ecode4)) {
11535 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11536 }
11537 arg4 = (PLFLT)(val4);
11538 plscolbga(arg1,arg2,arg3,arg4);
11539 resultobj = SWIG_Py_Void();
11540 return resultobj;
11541fail:
11542 return NULL;
11543}
11544
11545
11546SWIGINTERN PyObject *_wrap_plscolor(PyObject *self, PyObject *args) {
11547 PyObject *resultobj = 0;
11548 PLINT arg1 ;
11549 int val1 ;
11550 int ecode1 = 0 ;
11551 PyObject *swig_obj[1] ;
11552
11553 (void)self;
11554 if (!args) SWIG_fail;
11555 swig_obj[0] = args;
11556 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11557 if (!SWIG_IsOK(ecode1)) {
11558 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11559 }
11560 arg1 = (PLINT)(val1);
11561 plscolor(arg1);
11562 resultobj = SWIG_Py_Void();
11563 return resultobj;
11564fail:
11565 return NULL;
11566}
11567
11568
11569SWIGINTERN PyObject *_wrap_plscompression(PyObject *self, PyObject *args) {
11570 PyObject *resultobj = 0;
11571 PLINT arg1 ;
11572 int val1 ;
11573 int ecode1 = 0 ;
11574 PyObject *swig_obj[1] ;
11575
11576 (void)self;
11577 if (!args) SWIG_fail;
11578 swig_obj[0] = args;
11579 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11580 if (!SWIG_IsOK(ecode1)) {
11581 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11582 }
11583 arg1 = (PLINT)(val1);
11584 plscompression(arg1);
11585 resultobj = SWIG_Py_Void();
11586 return resultobj;
11587fail:
11588 return NULL;
11589}
11590
11591
11592SWIGINTERN PyObject *_wrap_plsdev(PyObject *self, PyObject *args) {
11593 PyObject *resultobj = 0;
11594 char *arg1 = 0 ;
11595 int res1 ;
11596 char *buf1 = 0 ;
11597 int alloc1 = 0 ;
11598 PyObject *swig_obj[1] ;
11599
11600 (void)self;
11601 if (!args) SWIG_fail;
11602 swig_obj[0] = args;
11603 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11604 if (!SWIG_IsOK(res1)) {
11605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11606 }
11607 arg1 = (char *)(buf1);
11608 plsdev((char const *)arg1);
11609 resultobj = SWIG_Py_Void();
11610 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11611 return resultobj;
11612fail:
11613 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11614 return NULL;
11615}
11616
11617
11618SWIGINTERN PyObject *_wrap_plsdidev(PyObject *self, PyObject *args) {
11619 PyObject *resultobj = 0;
11620 PLFLT arg1 ;
11621 PLFLT arg2 ;
11622 PLFLT arg3 ;
11623 PLFLT arg4 ;
11624 double val1 ;
11625 int ecode1 = 0 ;
11626 double val2 ;
11627 int ecode2 = 0 ;
11628 double val3 ;
11629 int ecode3 = 0 ;
11630 double val4 ;
11631 int ecode4 = 0 ;
11632 PyObject *swig_obj[4] ;
11633
11634 (void)self;
11635 if (!SWIG_Python_UnpackTuple(args, "plsdidev", 4, 4, swig_obj)) SWIG_fail;
11636 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11637 if (!SWIG_IsOK(ecode1)) {
11638 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11639 }
11640 arg1 = (PLFLT)(val1);
11641 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11642 if (!SWIG_IsOK(ecode2)) {
11643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11644 }
11645 arg2 = (PLFLT)(val2);
11646 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11647 if (!SWIG_IsOK(ecode3)) {
11648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11649 }
11650 arg3 = (PLFLT)(val3);
11651 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11652 if (!SWIG_IsOK(ecode4)) {
11653 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11654 }
11655 arg4 = (PLFLT)(val4);
11656 plsdidev(arg1,arg2,arg3,arg4);
11657 resultobj = SWIG_Py_Void();
11658 return resultobj;
11659fail:
11660 return NULL;
11661}
11662
11663
11664SWIGINTERN PyObject *_wrap_plsdimap(PyObject *self, PyObject *args) {
11665 PyObject *resultobj = 0;
11666 PLINT arg1 ;
11667 PLINT arg2 ;
11668 PLINT arg3 ;
11669 PLINT arg4 ;
11670 PLFLT arg5 ;
11671 PLFLT arg6 ;
11672 int val1 ;
11673 int ecode1 = 0 ;
11674 int val2 ;
11675 int ecode2 = 0 ;
11676 int val3 ;
11677 int ecode3 = 0 ;
11678 int val4 ;
11679 int ecode4 = 0 ;
11680 double val5 ;
11681 int ecode5 = 0 ;
11682 double val6 ;
11683 int ecode6 = 0 ;
11684 PyObject *swig_obj[6] ;
11685
11686 (void)self;
11687 if (!SWIG_Python_UnpackTuple(args, "plsdimap", 6, 6, swig_obj)) SWIG_fail;
11688 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11689 if (!SWIG_IsOK(ecode1)) {
11690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11691 }
11692 arg1 = (PLINT)(val1);
11693 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11694 if (!SWIG_IsOK(ecode2)) {
11695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11696 }
11697 arg2 = (PLINT)(val2);
11698 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11699 if (!SWIG_IsOK(ecode3)) {
11700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11701 }
11702 arg3 = (PLINT)(val3);
11703 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11704 if (!SWIG_IsOK(ecode4)) {
11705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11706 }
11707 arg4 = (PLINT)(val4);
11708 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11709 if (!SWIG_IsOK(ecode5)) {
11710 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11711 }
11712 arg5 = (PLFLT)(val5);
11713 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
11714 if (!SWIG_IsOK(ecode6)) {
11715 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11716 }
11717 arg6 = (PLFLT)(val6);
11718 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11719 resultobj = SWIG_Py_Void();
11720 return resultobj;
11721fail:
11722 return NULL;
11723}
11724
11725
11726SWIGINTERN PyObject *_wrap_plsdiori(PyObject *self, PyObject *args) {
11727 PyObject *resultobj = 0;
11728 PLFLT arg1 ;
11729 double val1 ;
11730 int ecode1 = 0 ;
11731 PyObject *swig_obj[1] ;
11732
11733 (void)self;
11734 if (!args) SWIG_fail;
11735 swig_obj[0] = args;
11736 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11737 if (!SWIG_IsOK(ecode1)) {
11738 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11739 }
11740 arg1 = (PLFLT)(val1);
11741 plsdiori(arg1);
11742 resultobj = SWIG_Py_Void();
11743 return resultobj;
11744fail:
11745 return NULL;
11746}
11747
11748
11749SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *self, PyObject *args) {
11750 PyObject *resultobj = 0;
11751 PLFLT arg1 ;
11752 PLFLT arg2 ;
11753 PLFLT arg3 ;
11754 PLFLT arg4 ;
11755 double val1 ;
11756 int ecode1 = 0 ;
11757 double val2 ;
11758 int ecode2 = 0 ;
11759 double val3 ;
11760 int ecode3 = 0 ;
11761 double val4 ;
11762 int ecode4 = 0 ;
11763 PyObject *swig_obj[4] ;
11764
11765 (void)self;
11766 if (!SWIG_Python_UnpackTuple(args, "plsdiplt", 4, 4, swig_obj)) SWIG_fail;
11767 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11768 if (!SWIG_IsOK(ecode1)) {
11769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11770 }
11771 arg1 = (PLFLT)(val1);
11772 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11773 if (!SWIG_IsOK(ecode2)) {
11774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11775 }
11776 arg2 = (PLFLT)(val2);
11777 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11778 if (!SWIG_IsOK(ecode3)) {
11779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11780 }
11781 arg3 = (PLFLT)(val3);
11782 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11783 if (!SWIG_IsOK(ecode4)) {
11784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11785 }
11786 arg4 = (PLFLT)(val4);
11787 plsdiplt(arg1,arg2,arg3,arg4);
11788 resultobj = SWIG_Py_Void();
11789 return resultobj;
11790fail:
11791 return NULL;
11792}
11793
11794
11795SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *self, PyObject *args) {
11796 PyObject *resultobj = 0;
11797 PLFLT arg1 ;
11798 PLFLT arg2 ;
11799 PLFLT arg3 ;
11800 PLFLT arg4 ;
11801 double val1 ;
11802 int ecode1 = 0 ;
11803 double val2 ;
11804 int ecode2 = 0 ;
11805 double val3 ;
11806 int ecode3 = 0 ;
11807 double val4 ;
11808 int ecode4 = 0 ;
11809 PyObject *swig_obj[4] ;
11810
11811 (void)self;
11812 if (!SWIG_Python_UnpackTuple(args, "plsdiplz", 4, 4, swig_obj)) SWIG_fail;
11813 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11814 if (!SWIG_IsOK(ecode1)) {
11815 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11816 }
11817 arg1 = (PLFLT)(val1);
11818 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11819 if (!SWIG_IsOK(ecode2)) {
11820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11821 }
11822 arg2 = (PLFLT)(val2);
11823 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11824 if (!SWIG_IsOK(ecode3)) {
11825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11826 }
11827 arg3 = (PLFLT)(val3);
11828 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11829 if (!SWIG_IsOK(ecode4)) {
11830 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11831 }
11832 arg4 = (PLFLT)(val4);
11833 plsdiplz(arg1,arg2,arg3,arg4);
11834 resultobj = SWIG_Py_Void();
11835 return resultobj;
11836fail:
11837 return NULL;
11838}
11839
11840
11841SWIGINTERN PyObject *_wrap_plseed(PyObject *self, PyObject *args) {
11842 PyObject *resultobj = 0;
11843 unsigned int arg1 ;
11844 unsigned int val1 ;
11845 int ecode1 = 0 ;
11846 PyObject *swig_obj[1] ;
11847
11848 (void)self;
11849 if (!args) SWIG_fail;
11850 swig_obj[0] = args;
11851 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11852 if (!SWIG_IsOK(ecode1)) {
11853 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11854 }
11855 arg1 = (unsigned int)(val1);
11856 plseed(arg1);
11857 resultobj = SWIG_Py_Void();
11858 return resultobj;
11859fail:
11860 return NULL;
11861}
11862
11863
11864SWIGINTERN PyObject *_wrap_plsesc(PyObject *self, PyObject *args) {
11865 PyObject *resultobj = 0;
11866 char arg1 ;
11867 char val1 ;
11868 int ecode1 = 0 ;
11869 PyObject *swig_obj[1] ;
11870
11871 (void)self;
11872 if (!args) SWIG_fail;
11873 swig_obj[0] = args;
11874 ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
11875 if (!SWIG_IsOK(ecode1)) {
11876 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11877 }
11878 arg1 = (char)(val1);
11879 plsesc(arg1);
11880 resultobj = SWIG_Py_Void();
11881 return resultobj;
11882fail:
11883 return NULL;
11884}
11885
11886
11887SWIGINTERN PyObject *_wrap_plsetopt(PyObject *self, PyObject *args) {
11888 PyObject *resultobj = 0;
11889 char *arg1 = 0 ;
11890 char *arg2 = 0 ;
11891 int res1 ;
11892 char *buf1 = 0 ;
11893 int alloc1 = 0 ;
11894 int res2 ;
11895 char *buf2 = 0 ;
11896 int alloc2 = 0 ;
11897 PyObject *swig_obj[2] ;
11898 PLINT result;
11899
11900 (void)self;
11901 if (!SWIG_Python_UnpackTuple(args, "plsetopt", 2, 2, swig_obj)) SWIG_fail;
11902 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11903 if (!SWIG_IsOK(res1)) {
11904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11905 }
11906 arg1 = (char *)(buf1);
11907 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11908 if (!SWIG_IsOK(res2)) {
11909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11910 }
11911 arg2 = (char *)(buf2);
11912 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11913 resultobj = SWIG_From_int((int)(result));
11914 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11915 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11916 return resultobj;
11917fail:
11918 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11919 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11920 return NULL;
11921}
11922
11923
11924SWIGINTERN PyObject *_wrap_plsfam(PyObject *self, PyObject *args) {
11925 PyObject *resultobj = 0;
11926 PLINT arg1 ;
11927 PLINT arg2 ;
11928 PLINT arg3 ;
11929 int val1 ;
11930 int ecode1 = 0 ;
11931 int val2 ;
11932 int ecode2 = 0 ;
11933 int val3 ;
11934 int ecode3 = 0 ;
11935 PyObject *swig_obj[3] ;
11936
11937 (void)self;
11938 if (!SWIG_Python_UnpackTuple(args, "plsfam", 3, 3, swig_obj)) SWIG_fail;
11939 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11940 if (!SWIG_IsOK(ecode1)) {
11941 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11942 }
11943 arg1 = (PLINT)(val1);
11944 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11945 if (!SWIG_IsOK(ecode2)) {
11946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11947 }
11948 arg2 = (PLINT)(val2);
11949 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11950 if (!SWIG_IsOK(ecode3)) {
11951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11952 }
11953 arg3 = (PLINT)(val3);
11954 plsfam(arg1,arg2,arg3);
11955 resultobj = SWIG_Py_Void();
11956 return resultobj;
11957fail:
11958 return NULL;
11959}
11960
11961
11962SWIGINTERN PyObject *_wrap_plsfci(PyObject *self, PyObject *args) {
11963 PyObject *resultobj = 0;
11964 PLUNICODE arg1 ;
11965 unsigned int val1 ;
11966 int ecode1 = 0 ;
11967 PyObject *swig_obj[1] ;
11968
11969 (void)self;
11970 if (!args) SWIG_fail;
11971 swig_obj[0] = args;
11972 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11973 if (!SWIG_IsOK(ecode1)) {
11974 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11975 }
11976 arg1 = (PLUNICODE)(val1);
11977 plsfci(arg1);
11978 resultobj = SWIG_Py_Void();
11979 return resultobj;
11980fail:
11981 return NULL;
11982}
11983
11984
11985SWIGINTERN PyObject *_wrap_plsfnam(PyObject *self, PyObject *args) {
11986 PyObject *resultobj = 0;
11987 char *arg1 = 0 ;
11988 int res1 ;
11989 char *buf1 = 0 ;
11990 int alloc1 = 0 ;
11991 PyObject *swig_obj[1] ;
11992
11993 (void)self;
11994 if (!args) SWIG_fail;
11995 swig_obj[0] = args;
11996 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11997 if (!SWIG_IsOK(res1)) {
11998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11999 }
12000 arg1 = (char *)(buf1);
12001 plsfnam((char const *)arg1);
12002 resultobj = SWIG_Py_Void();
12003 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12004 return resultobj;
12005fail:
12006 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12007 return NULL;
12008}
12009
12010
12011SWIGINTERN PyObject *_wrap_plsfont(PyObject *self, PyObject *args) {
12012 PyObject *resultobj = 0;
12013 PLINT arg1 ;
12014 PLINT arg2 ;
12015 PLINT arg3 ;
12016 int val1 ;
12017 int ecode1 = 0 ;
12018 int val2 ;
12019 int ecode2 = 0 ;
12020 int val3 ;
12021 int ecode3 = 0 ;
12022 PyObject *swig_obj[3] ;
12023
12024 (void)self;
12025 if (!SWIG_Python_UnpackTuple(args, "plsfont", 3, 3, swig_obj)) SWIG_fail;
12026 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12027 if (!SWIG_IsOK(ecode1)) {
12028 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
12029 }
12030 arg1 = (PLINT)(val1);
12031 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12032 if (!SWIG_IsOK(ecode2)) {
12033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
12034 }
12035 arg2 = (PLINT)(val2);
12036 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12037 if (!SWIG_IsOK(ecode3)) {
12038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
12039 }
12040 arg3 = (PLINT)(val3);
12041 plsfont(arg1,arg2,arg3);
12042 resultobj = SWIG_Py_Void();
12043 return resultobj;
12044fail:
12045 return NULL;
12046}
12047
12048
12049SWIGINTERN PyObject *_wrap_plshades(PyObject *self, PyObject *args) {
12050 PyObject *resultobj = 0;
12051 PLFLT **arg1 = 0 ;
12052 PLINT arg2 ;
12053 PLINT arg3 ;
12054 defined_func arg4 = 0 ;
12055 PLFLT arg5 ;
12056 PLFLT arg6 ;
12057 PLFLT arg7 ;
12058 PLFLT arg8 ;
12059 PLFLT *arg9 = 0 ;
12060 PLINT arg10 ;
12061 PLFLT arg11 ;
12062 PLINT arg12 ;
12063 PLFLT arg13 ;
12064 fill_func arg14 = 0 ;
12065 PLBOOL arg15 ;
12066 pltr_func arg16 = 0 ;
12067 PLPointer arg17 = 0 ;
12068 PyArrayObject *tmp1 = NULL ;
12069 double val5 ;
12070 int ecode5 = 0 ;
12071 double val6 ;
12072 int ecode6 = 0 ;
12073 double val7 ;
12074 int ecode7 = 0 ;
12075 double val8 ;
12076 int ecode8 = 0 ;
12077 PyArrayObject *tmp9 = NULL ;
12078 double val11 ;
12079 int ecode11 = 0 ;
12080 int val12 ;
12081 int ecode12 = 0 ;
12082 double val13 ;
12083 int ecode13 = 0 ;
12084 int val15 ;
12085 int ecode15 = 0 ;
12086 PyObject *swig_obj[12] ;
12087
12088 {
12089 python_pltr = 0;
12090 arg16 = NULL;
12091 }
12092 {
12093 arg17 = NULL;
12094 }
12095 {
12096 arg4 = NULL;
12097 }
12098 {
12099 arg14 = plfill;
12100 }
12101 (void)self;
12102 if (!SWIG_Python_UnpackTuple(args, "plshades", 10, 12, swig_obj)) SWIG_fail;
12103 {
12104 int i, size;
12105 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12106 if ( tmp1 == NULL )
12107 return NULL;
12108 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12109 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12110 size = arg3;
12111 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12112 for ( i = 0; i < arg2; i++ )
12113 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12114 }
12115 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12116 if (!SWIG_IsOK(ecode5)) {
12117 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
12118 }
12119 arg5 = (PLFLT)(val5);
12120 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12121 if (!SWIG_IsOK(ecode6)) {
12122 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
12123 }
12124 arg6 = (PLFLT)(val6);
12125 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12126 if (!SWIG_IsOK(ecode7)) {
12127 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
12128 }
12129 arg7 = (PLFLT)(val7);
12130 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12131 if (!SWIG_IsOK(ecode8)) {
12132 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
12133 }
12134 arg8 = (PLFLT)(val8);
12135 {
12136 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
12137 if ( tmp9 == NULL )
12138 return NULL;
12139 arg10 = PyArray_DIMS( tmp9 )[0];
12140 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
12141 }
12142 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
12143 if (!SWIG_IsOK(ecode11)) {
12144 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
12145 }
12146 arg11 = (PLFLT)(val11);
12147 ecode12 = SWIG_AsVal_int(swig_obj[7], &val12);
12148 if (!SWIG_IsOK(ecode12)) {
12149 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
12150 }
12151 arg12 = (PLINT)(val12);
12152 ecode13 = SWIG_AsVal_double(swig_obj[8], &val13);
12153 if (!SWIG_IsOK(ecode13)) {
12154 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
12155 }
12156 arg13 = (PLFLT)(val13);
12157 ecode15 = SWIG_AsVal_int(swig_obj[9], &val15);
12158 if (!SWIG_IsOK(ecode15)) {
12159 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
12160 }
12161 arg15 = (PLBOOL)(val15);
12162 if (swig_obj[10]) {
12163 {
12164 // it must be a callable or None
12165 if ( swig_obj[10] == Py_None )
12166 {
12167 arg16 = NULL;
12168 }
12169 else
12170 {
12171 if ( !PyCallable_Check( (PyObject *) swig_obj[10] ) )
12172 {
12173 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12174 return NULL;
12175 }
12176 arg16 = marshal_pltr( swig_obj[10] );
12177 }
12178 }
12179 }
12180 if (swig_obj[11]) {
12181 {
12182 if ( swig_obj[11] == Py_None )
12183 arg17 = NULL;
12184 else
12185 {
12186 arg17 = marshal_PLPointer( swig_obj[11], 0 );
12187 }
12188 }
12189 }
12190 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
12191 resultobj = SWIG_Py_Void();
12192 {
12193 Py_CLEAR( tmp1 );
12194 free( arg1 );
12195 }
12196 {
12197 Py_CLEAR( tmp9 );
12198 }
12199 {
12200 cleanup_pltr();
12201 }
12202 {
12204 }
12205 return resultobj;
12206fail:
12207 {
12208 Py_CLEAR( tmp1 );
12209 free( arg1 );
12210 }
12211 {
12212 Py_CLEAR( tmp9 );
12213 }
12214 {
12215 cleanup_pltr();
12216 }
12217 {
12219 }
12220 return NULL;
12221}
12222
12223
12224SWIGINTERN PyObject *_wrap_plshade(PyObject *self, PyObject *args) {
12225 PyObject *resultobj = 0;
12226 PLFLT **arg1 = 0 ;
12227 PLINT arg2 ;
12228 PLINT arg3 ;
12229 defined_func arg4 = 0 ;
12230 PLFLT arg5 ;
12231 PLFLT arg6 ;
12232 PLFLT arg7 ;
12233 PLFLT arg8 ;
12234 PLFLT arg9 ;
12235 PLFLT arg10 ;
12236 PLINT arg11 ;
12237 PLFLT arg12 ;
12238 PLFLT arg13 ;
12239 PLINT arg14 ;
12240 PLFLT arg15 ;
12241 PLINT arg16 ;
12242 PLFLT arg17 ;
12243 fill_func arg18 = 0 ;
12244 PLBOOL arg19 ;
12245 pltr_func arg20 = 0 ;
12246 PLPointer arg21 = 0 ;
12247 PyArrayObject *tmp1 = NULL ;
12248 double val5 ;
12249 int ecode5 = 0 ;
12250 double val6 ;
12251 int ecode6 = 0 ;
12252 double val7 ;
12253 int ecode7 = 0 ;
12254 double val8 ;
12255 int ecode8 = 0 ;
12256 double val9 ;
12257 int ecode9 = 0 ;
12258 double val10 ;
12259 int ecode10 = 0 ;
12260 int val11 ;
12261 int ecode11 = 0 ;
12262 double val12 ;
12263 int ecode12 = 0 ;
12264 double val13 ;
12265 int ecode13 = 0 ;
12266 int val14 ;
12267 int ecode14 = 0 ;
12268 double val15 ;
12269 int ecode15 = 0 ;
12270 int val16 ;
12271 int ecode16 = 0 ;
12272 double val17 ;
12273 int ecode17 = 0 ;
12274 int val19 ;
12275 int ecode19 = 0 ;
12276 PyObject *swig_obj[17] ;
12277
12278 {
12279 python_pltr = 0;
12280 arg20 = NULL;
12281 }
12282 {
12283 arg21 = NULL;
12284 }
12285 {
12286 arg4 = NULL;
12287 }
12288 {
12289 arg18 = plfill;
12290 }
12291 (void)self;
12292 if (!SWIG_Python_UnpackTuple(args, "plshade", 15, 17, swig_obj)) SWIG_fail;
12293 {
12294 int i, size;
12295 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12296 if ( tmp1 == NULL )
12297 return NULL;
12298 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12299 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12300 size = arg3;
12301 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12302 for ( i = 0; i < arg2; i++ )
12303 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12304 }
12305 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12306 if (!SWIG_IsOK(ecode5)) {
12307 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12308 }
12309 arg5 = (PLFLT)(val5);
12310 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12311 if (!SWIG_IsOK(ecode6)) {
12312 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12313 }
12314 arg6 = (PLFLT)(val6);
12315 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12316 if (!SWIG_IsOK(ecode7)) {
12317 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12318 }
12319 arg7 = (PLFLT)(val7);
12320 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12321 if (!SWIG_IsOK(ecode8)) {
12322 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12323 }
12324 arg8 = (PLFLT)(val8);
12325 ecode9 = SWIG_AsVal_double(swig_obj[5], &val9);
12326 if (!SWIG_IsOK(ecode9)) {
12327 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12328 }
12329 arg9 = (PLFLT)(val9);
12330 ecode10 = SWIG_AsVal_double(swig_obj[6], &val10);
12331 if (!SWIG_IsOK(ecode10)) {
12332 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12333 }
12334 arg10 = (PLFLT)(val10);
12335 ecode11 = SWIG_AsVal_int(swig_obj[7], &val11);
12336 if (!SWIG_IsOK(ecode11)) {
12337 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12338 }
12339 arg11 = (PLINT)(val11);
12340 ecode12 = SWIG_AsVal_double(swig_obj[8], &val12);
12341 if (!SWIG_IsOK(ecode12)) {
12342 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12343 }
12344 arg12 = (PLFLT)(val12);
12345 ecode13 = SWIG_AsVal_double(swig_obj[9], &val13);
12346 if (!SWIG_IsOK(ecode13)) {
12347 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12348 }
12349 arg13 = (PLFLT)(val13);
12350 ecode14 = SWIG_AsVal_int(swig_obj[10], &val14);
12351 if (!SWIG_IsOK(ecode14)) {
12352 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12353 }
12354 arg14 = (PLINT)(val14);
12355 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
12356 if (!SWIG_IsOK(ecode15)) {
12357 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12358 }
12359 arg15 = (PLFLT)(val15);
12360 ecode16 = SWIG_AsVal_int(swig_obj[12], &val16);
12361 if (!SWIG_IsOK(ecode16)) {
12362 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12363 }
12364 arg16 = (PLINT)(val16);
12365 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
12366 if (!SWIG_IsOK(ecode17)) {
12367 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12368 }
12369 arg17 = (PLFLT)(val17);
12370 ecode19 = SWIG_AsVal_int(swig_obj[14], &val19);
12371 if (!SWIG_IsOK(ecode19)) {
12372 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12373 }
12374 arg19 = (PLBOOL)(val19);
12375 if (swig_obj[15]) {
12376 {
12377 // it must be a callable or None
12378 if ( swig_obj[15] == Py_None )
12379 {
12380 arg20 = NULL;
12381 }
12382 else
12383 {
12384 if ( !PyCallable_Check( (PyObject *) swig_obj[15] ) )
12385 {
12386 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12387 return NULL;
12388 }
12389 arg20 = marshal_pltr( swig_obj[15] );
12390 }
12391 }
12392 }
12393 if (swig_obj[16]) {
12394 {
12395 if ( swig_obj[16] == Py_None )
12396 arg21 = NULL;
12397 else
12398 {
12399 arg21 = marshal_PLPointer( swig_obj[16], 0 );
12400 }
12401 }
12402 }
12403 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12404 resultobj = SWIG_Py_Void();
12405 {
12406 Py_CLEAR( tmp1 );
12407 free( arg1 );
12408 }
12409 {
12410 cleanup_pltr();
12411 }
12412 {
12414 }
12415 return resultobj;
12416fail:
12417 {
12418 Py_CLEAR( tmp1 );
12419 free( arg1 );
12420 }
12421 {
12422 cleanup_pltr();
12423 }
12424 {
12426 }
12427 return NULL;
12428}
12429
12430
12431SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *self, PyObject *args) {
12432 PyObject *resultobj = 0;
12433 label_func arg1 = 0 ;
12434 PLPointer arg2 = 0 ;
12435 int res2 ;
12436 PyObject *swig_obj[2] ;
12437
12438 (void)self;
12439 if (!SWIG_Python_UnpackTuple(args, "plslabelfunc", 2, 2, swig_obj)) SWIG_fail;
12440 {
12441 // Release reference to previous function if applicable
12442 if ( python_label )
12443 {
12444 Py_CLEAR( python_label );
12445 python_label = 0;
12446 }
12447 // it must be a callable or None
12448 if ( swig_obj[0] == Py_None )
12449 {
12450 arg1 = NULL;
12451 }
12452 else
12453 {
12454 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12455 {
12456 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12457 return NULL;
12458 }
12459 // hold a reference to it
12460 Py_XINCREF( (PyObject *) swig_obj[0] );
12461 python_label = (PyObject *) swig_obj[0];
12462 // this function handles calling the python function
12463 arg1 = do_label_callback;
12464 }
12465 }
12466 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12467 if (!SWIG_IsOK(res2)) {
12468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12469 }
12470 plslabelfunc(arg1,arg2);
12471 resultobj = SWIG_Py_Void();
12472 return resultobj;
12473fail:
12474 return NULL;
12475}
12476
12477
12478SWIGINTERN PyObject *_wrap_plsmaj(PyObject *self, PyObject *args) {
12479 PyObject *resultobj = 0;
12480 PLFLT arg1 ;
12481 PLFLT arg2 ;
12482 double val1 ;
12483 int ecode1 = 0 ;
12484 double val2 ;
12485 int ecode2 = 0 ;
12486 PyObject *swig_obj[2] ;
12487
12488 (void)self;
12489 if (!SWIG_Python_UnpackTuple(args, "plsmaj", 2, 2, swig_obj)) SWIG_fail;
12490 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12491 if (!SWIG_IsOK(ecode1)) {
12492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12493 }
12494 arg1 = (PLFLT)(val1);
12495 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12496 if (!SWIG_IsOK(ecode2)) {
12497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12498 }
12499 arg2 = (PLFLT)(val2);
12500 plsmaj(arg1,arg2);
12501 resultobj = SWIG_Py_Void();
12502 return resultobj;
12503fail:
12504 return NULL;
12505}
12506
12507
12508SWIGINTERN PyObject *_wrap_plsmem(PyObject *self, PyObject *args) {
12509 PyObject *resultobj = 0;
12510 PLINT arg1 ;
12511 PLINT arg2 ;
12512 void *arg3 = 0 ;
12513 int val1 ;
12514 int ecode1 = 0 ;
12515 int val2 ;
12516 int ecode2 = 0 ;
12517 PyObject *swig_obj[3] ;
12518
12519 (void)self;
12520 if (!SWIG_Python_UnpackTuple(args, "plsmem", 3, 3, swig_obj)) SWIG_fail;
12521 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12522 if (!SWIG_IsOK(ecode1)) {
12523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12524 }
12525 arg1 = (PLINT)(val1);
12526 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12527 if (!SWIG_IsOK(ecode2)) {
12528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12529 }
12530 arg2 = (PLINT)(val2);
12531 {
12532 int res; void *buf = 0;
12533#ifndef Py_LIMITED_API
12534 Py_buffer view;
12535 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12536#else
12537#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12538#pragma GCC diagnostic push
12539#pragma GCC diagnostic ignored "-Wdeprecated"
12540#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12541#elif defined(_MSC_VER)
12542#pragma warning(push)
12543#pragma warning(disable: 4996)
12544#endif
12545 Py_ssize_t size;
12546 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12547#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12548#pragma GCC diagnostic pop
12549#elif defined(_MSC_VER)
12550#pragma warning(pop)
12551#endif
12552#endif
12553 if (res < 0) {
12554 PyErr_Clear();
12555 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem)""'");
12556 }
12557#ifndef Py_LIMITED_API
12558 buf = view.buf;
12559 PyBuffer_Release(&view);
12560#endif
12561 arg3 = (void *) buf;
12562 }
12563 plsmem(arg1,arg2,arg3);
12564 resultobj = SWIG_Py_Void();
12565 return resultobj;
12566fail:
12567 return NULL;
12568}
12569
12570
12571SWIGINTERN PyObject *_wrap_plsmema(PyObject *self, PyObject *args) {
12572 PyObject *resultobj = 0;
12573 PLINT arg1 ;
12574 PLINT arg2 ;
12575 void *arg3 = 0 ;
12576 int val1 ;
12577 int ecode1 = 0 ;
12578 int val2 ;
12579 int ecode2 = 0 ;
12580 PyObject *swig_obj[3] ;
12581
12582 (void)self;
12583 if (!SWIG_Python_UnpackTuple(args, "plsmema", 3, 3, swig_obj)) SWIG_fail;
12584 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12585 if (!SWIG_IsOK(ecode1)) {
12586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12587 }
12588 arg1 = (PLINT)(val1);
12589 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12590 if (!SWIG_IsOK(ecode2)) {
12591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12592 }
12593 arg2 = (PLINT)(val2);
12594 {
12595 int res; void *buf = 0;
12596#ifndef Py_LIMITED_API
12597 Py_buffer view;
12598 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12599#else
12600#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12601#pragma GCC diagnostic push
12602#pragma GCC diagnostic ignored "-Wdeprecated"
12603#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12604#elif defined(_MSC_VER)
12605#pragma warning(push)
12606#pragma warning(disable: 4996)
12607#endif
12608 Py_ssize_t size;
12609 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12610#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12611#pragma GCC diagnostic pop
12612#elif defined(_MSC_VER)
12613#pragma warning(pop)
12614#endif
12615#endif
12616 if (res < 0) {
12617 PyErr_Clear();
12618 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem)""'");
12619 }
12620#ifndef Py_LIMITED_API
12621 buf = view.buf;
12622 PyBuffer_Release(&view);
12623#endif
12624 arg3 = (void *) buf;
12625 }
12626 plsmema(arg1,arg2,arg3);
12627 resultobj = SWIG_Py_Void();
12628 return resultobj;
12629fail:
12630 return NULL;
12631}
12632
12633
12634SWIGINTERN PyObject *_wrap_plsmin(PyObject *self, PyObject *args) {
12635 PyObject *resultobj = 0;
12636 PLFLT arg1 ;
12637 PLFLT arg2 ;
12638 double val1 ;
12639 int ecode1 = 0 ;
12640 double val2 ;
12641 int ecode2 = 0 ;
12642 PyObject *swig_obj[2] ;
12643
12644 (void)self;
12645 if (!SWIG_Python_UnpackTuple(args, "plsmin", 2, 2, swig_obj)) SWIG_fail;
12646 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12647 if (!SWIG_IsOK(ecode1)) {
12648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12649 }
12650 arg1 = (PLFLT)(val1);
12651 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12652 if (!SWIG_IsOK(ecode2)) {
12653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12654 }
12655 arg2 = (PLFLT)(val2);
12656 plsmin(arg1,arg2);
12657 resultobj = SWIG_Py_Void();
12658 return resultobj;
12659fail:
12660 return NULL;
12661}
12662
12663
12664SWIGINTERN PyObject *_wrap_plsori(PyObject *self, PyObject *args) {
12665 PyObject *resultobj = 0;
12666 PLINT arg1 ;
12667 int val1 ;
12668 int ecode1 = 0 ;
12669 PyObject *swig_obj[1] ;
12670
12671 (void)self;
12672 if (!args) SWIG_fail;
12673 swig_obj[0] = args;
12674 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12675 if (!SWIG_IsOK(ecode1)) {
12676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12677 }
12678 arg1 = (PLINT)(val1);
12679 plsori(arg1);
12680 resultobj = SWIG_Py_Void();
12681 return resultobj;
12682fail:
12683 return NULL;
12684}
12685
12686
12687SWIGINTERN PyObject *_wrap_plspage(PyObject *self, PyObject *args) {
12688 PyObject *resultobj = 0;
12689 PLFLT arg1 ;
12690 PLFLT arg2 ;
12691 PLINT arg3 ;
12692 PLINT arg4 ;
12693 PLINT arg5 ;
12694 PLINT arg6 ;
12695 double val1 ;
12696 int ecode1 = 0 ;
12697 double val2 ;
12698 int ecode2 = 0 ;
12699 int val3 ;
12700 int ecode3 = 0 ;
12701 int val4 ;
12702 int ecode4 = 0 ;
12703 int val5 ;
12704 int ecode5 = 0 ;
12705 int val6 ;
12706 int ecode6 = 0 ;
12707 PyObject *swig_obj[6] ;
12708
12709 (void)self;
12710 if (!SWIG_Python_UnpackTuple(args, "plspage", 6, 6, swig_obj)) SWIG_fail;
12711 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12712 if (!SWIG_IsOK(ecode1)) {
12713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12714 }
12715 arg1 = (PLFLT)(val1);
12716 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12717 if (!SWIG_IsOK(ecode2)) {
12718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12719 }
12720 arg2 = (PLFLT)(val2);
12721 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12722 if (!SWIG_IsOK(ecode3)) {
12723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12724 }
12725 arg3 = (PLINT)(val3);
12726 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
12727 if (!SWIG_IsOK(ecode4)) {
12728 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12729 }
12730 arg4 = (PLINT)(val4);
12731 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
12732 if (!SWIG_IsOK(ecode5)) {
12733 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12734 }
12735 arg5 = (PLINT)(val5);
12736 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
12737 if (!SWIG_IsOK(ecode6)) {
12738 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12739 }
12740 arg6 = (PLINT)(val6);
12741 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12742 resultobj = SWIG_Py_Void();
12743 return resultobj;
12744fail:
12745 return NULL;
12746}
12747
12748
12749SWIGINTERN PyObject *_wrap_plspal0(PyObject *self, PyObject *args) {
12750 PyObject *resultobj = 0;
12751 char *arg1 = 0 ;
12752 int res1 ;
12753 char *buf1 = 0 ;
12754 int alloc1 = 0 ;
12755 PyObject *swig_obj[1] ;
12756
12757 (void)self;
12758 if (!args) SWIG_fail;
12759 swig_obj[0] = args;
12760 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12761 if (!SWIG_IsOK(res1)) {
12762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12763 }
12764 arg1 = (char *)(buf1);
12765 plspal0((char const *)arg1);
12766 resultobj = SWIG_Py_Void();
12767 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12768 return resultobj;
12769fail:
12770 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12771 return NULL;
12772}
12773
12774
12775SWIGINTERN PyObject *_wrap_plspal1(PyObject *self, PyObject *args) {
12776 PyObject *resultobj = 0;
12777 char *arg1 = 0 ;
12778 PLBOOL arg2 ;
12779 int res1 ;
12780 char *buf1 = 0 ;
12781 int alloc1 = 0 ;
12782 int val2 ;
12783 int ecode2 = 0 ;
12784 PyObject *swig_obj[2] ;
12785
12786 (void)self;
12787 if (!SWIG_Python_UnpackTuple(args, "plspal1", 2, 2, swig_obj)) SWIG_fail;
12788 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12789 if (!SWIG_IsOK(res1)) {
12790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12791 }
12792 arg1 = (char *)(buf1);
12793 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12794 if (!SWIG_IsOK(ecode2)) {
12795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12796 }
12797 arg2 = (PLBOOL)(val2);
12798 plspal1((char const *)arg1,arg2);
12799 resultobj = SWIG_Py_Void();
12800 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12801 return resultobj;
12802fail:
12803 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12804 return NULL;
12805}
12806
12807
12808SWIGINTERN PyObject *_wrap_plspause(PyObject *self, PyObject *args) {
12809 PyObject *resultobj = 0;
12810 PLBOOL arg1 ;
12811 int val1 ;
12812 int ecode1 = 0 ;
12813 PyObject *swig_obj[1] ;
12814
12815 (void)self;
12816 if (!args) SWIG_fail;
12817 swig_obj[0] = args;
12818 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12819 if (!SWIG_IsOK(ecode1)) {
12820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12821 }
12822 arg1 = (PLBOOL)(val1);
12823 plspause(arg1);
12824 resultobj = SWIG_Py_Void();
12825 return resultobj;
12826fail:
12827 return NULL;
12828}
12829
12830
12831SWIGINTERN PyObject *_wrap_plsstrm(PyObject *self, PyObject *args) {
12832 PyObject *resultobj = 0;
12833 PLINT arg1 ;
12834 int val1 ;
12835 int ecode1 = 0 ;
12836 PyObject *swig_obj[1] ;
12837
12838 (void)self;
12839 if (!args) SWIG_fail;
12840 swig_obj[0] = args;
12841 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12842 if (!SWIG_IsOK(ecode1)) {
12843 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12844 }
12845 arg1 = (PLINT)(val1);
12846 plsstrm(arg1);
12847 resultobj = SWIG_Py_Void();
12848 return resultobj;
12849fail:
12850 return NULL;
12851}
12852
12853
12854SWIGINTERN PyObject *_wrap_plssub(PyObject *self, PyObject *args) {
12855 PyObject *resultobj = 0;
12856 PLINT arg1 ;
12857 PLINT arg2 ;
12858 int val1 ;
12859 int ecode1 = 0 ;
12860 int val2 ;
12861 int ecode2 = 0 ;
12862 PyObject *swig_obj[2] ;
12863
12864 (void)self;
12865 if (!SWIG_Python_UnpackTuple(args, "plssub", 2, 2, swig_obj)) SWIG_fail;
12866 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12867 if (!SWIG_IsOK(ecode1)) {
12868 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12869 }
12870 arg1 = (PLINT)(val1);
12871 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12872 if (!SWIG_IsOK(ecode2)) {
12873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12874 }
12875 arg2 = (PLINT)(val2);
12876 plssub(arg1,arg2);
12877 resultobj = SWIG_Py_Void();
12878 return resultobj;
12879fail:
12880 return NULL;
12881}
12882
12883
12884SWIGINTERN PyObject *_wrap_plssym(PyObject *self, PyObject *args) {
12885 PyObject *resultobj = 0;
12886 PLFLT arg1 ;
12887 PLFLT arg2 ;
12888 double val1 ;
12889 int ecode1 = 0 ;
12890 double val2 ;
12891 int ecode2 = 0 ;
12892 PyObject *swig_obj[2] ;
12893
12894 (void)self;
12895 if (!SWIG_Python_UnpackTuple(args, "plssym", 2, 2, swig_obj)) SWIG_fail;
12896 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12897 if (!SWIG_IsOK(ecode1)) {
12898 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12899 }
12900 arg1 = (PLFLT)(val1);
12901 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12902 if (!SWIG_IsOK(ecode2)) {
12903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12904 }
12905 arg2 = (PLFLT)(val2);
12906 plssym(arg1,arg2);
12907 resultobj = SWIG_Py_Void();
12908 return resultobj;
12909fail:
12910 return NULL;
12911}
12912
12913
12914SWIGINTERN PyObject *_wrap_plstar(PyObject *self, PyObject *args) {
12915 PyObject *resultobj = 0;
12916 PLINT arg1 ;
12917 PLINT arg2 ;
12918 int val1 ;
12919 int ecode1 = 0 ;
12920 int val2 ;
12921 int ecode2 = 0 ;
12922 PyObject *swig_obj[2] ;
12923
12924 (void)self;
12925 if (!SWIG_Python_UnpackTuple(args, "plstar", 2, 2, swig_obj)) SWIG_fail;
12926 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12927 if (!SWIG_IsOK(ecode1)) {
12928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12929 }
12930 arg1 = (PLINT)(val1);
12931 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12932 if (!SWIG_IsOK(ecode2)) {
12933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12934 }
12935 arg2 = (PLINT)(val2);
12936 plstar(arg1,arg2);
12937 resultobj = SWIG_Py_Void();
12938 return resultobj;
12939fail:
12940 return NULL;
12941}
12942
12943
12944SWIGINTERN PyObject *_wrap_plstart(PyObject *self, PyObject *args) {
12945 PyObject *resultobj = 0;
12946 char *arg1 = 0 ;
12947 PLINT arg2 ;
12948 PLINT arg3 ;
12949 int res1 ;
12950 char *buf1 = 0 ;
12951 int alloc1 = 0 ;
12952 int val2 ;
12953 int ecode2 = 0 ;
12954 int val3 ;
12955 int ecode3 = 0 ;
12956 PyObject *swig_obj[3] ;
12957
12958 (void)self;
12959 if (!SWIG_Python_UnpackTuple(args, "plstart", 3, 3, swig_obj)) SWIG_fail;
12960 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12961 if (!SWIG_IsOK(res1)) {
12962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12963 }
12964 arg1 = (char *)(buf1);
12965 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12966 if (!SWIG_IsOK(ecode2)) {
12967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12968 }
12969 arg2 = (PLINT)(val2);
12970 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12971 if (!SWIG_IsOK(ecode3)) {
12972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12973 }
12974 arg3 = (PLINT)(val3);
12975 plstart((char const *)arg1,arg2,arg3);
12976 resultobj = SWIG_Py_Void();
12977 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12978 return resultobj;
12979fail:
12980 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12981 return NULL;
12982}
12983
12984
12985SWIGINTERN PyObject *_wrap_plstransform(PyObject *self, PyObject *args) {
12986 PyObject *resultobj = 0;
12987 ct_func arg1 = 0 ;
12988 PLPointer arg2 = 0 ;
12989 int res2 ;
12990 PyObject *swig_obj[2] ;
12991
12992 {
12993 python_ct = 0;
12994 arg1 = NULL;
12995 }
12996 (void)self;
12997 if (!SWIG_Python_UnpackTuple(args, "plstransform", 0, 2, swig_obj)) SWIG_fail;
12998 if (swig_obj[0]) {
12999 {
13000 if ( python_ct )
13001 cleanup_ct();
13002 // it must be a callable or none
13003 if ( swig_obj[0] == Py_None )
13004 {
13005 arg1 = NULL;
13006 }
13007 else
13008 {
13009 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13010 {
13011 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
13012 return NULL;
13013 }
13014 arg1 = marshal_ct( swig_obj[0] );
13015 }
13016 }
13017 }
13018 if (swig_obj[1]) {
13019 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
13020 if (!SWIG_IsOK(res2)) {
13021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
13022 }
13023 }
13024 plstransform(arg1,arg2);
13025 resultobj = SWIG_Py_Void();
13026 return resultobj;
13027fail:
13028 return NULL;
13029}
13030
13031
13032SWIGINTERN PyObject *_wrap_plstring(PyObject *self, PyObject *args) {
13033 PyObject *resultobj = 0;
13034 PLINT arg1 ;
13035 PLFLT *arg2 = 0 ;
13036 PLFLT *arg3 = 0 ;
13037 char *arg4 = 0 ;
13038 PyArrayObject *tmp1 = NULL ;
13039 PyArrayObject *tmp3 = NULL ;
13040 int res4 ;
13041 char *buf4 = 0 ;
13042 int alloc4 = 0 ;
13043 PyObject *swig_obj[3] ;
13044
13045 (void)self;
13046 if (!SWIG_Python_UnpackTuple(args, "plstring", 3, 3, swig_obj)) SWIG_fail;
13047 {
13048 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13049 if ( tmp1 == NULL )
13050 return NULL;
13051 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13052 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13053 }
13054 {
13055 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13056 if ( tmp3 == NULL )
13057 return NULL;
13058 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13059 {
13060 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13061 return NULL;
13062 }
13063 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13064 }
13065 res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
13066 if (!SWIG_IsOK(res4)) {
13067 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
13068 }
13069 arg4 = (char *)(buf4);
13070 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
13071 resultobj = SWIG_Py_Void();
13072 {
13073 Py_CLEAR( tmp1 );
13074 }
13075 {
13076 Py_CLEAR( tmp3 );
13077 }
13078 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13079 return resultobj;
13080fail:
13081 {
13082 Py_CLEAR( tmp1 );
13083 }
13084 {
13085 Py_CLEAR( tmp3 );
13086 }
13087 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13088 return NULL;
13089}
13090
13091
13092SWIGINTERN PyObject *_wrap_plstring3(PyObject *self, PyObject *args) {
13093 PyObject *resultobj = 0;
13094 PLINT arg1 ;
13095 PLFLT *arg2 = 0 ;
13096 PLFLT *arg3 = 0 ;
13097 PLFLT *arg4 = 0 ;
13098 char *arg5 = 0 ;
13099 PyArrayObject *tmp1 = NULL ;
13100 PyArrayObject *tmp3 = NULL ;
13101 PyArrayObject *tmp4 = NULL ;
13102 int res5 ;
13103 char *buf5 = 0 ;
13104 int alloc5 = 0 ;
13105 PyObject *swig_obj[4] ;
13106
13107 (void)self;
13108 if (!SWIG_Python_UnpackTuple(args, "plstring3", 4, 4, swig_obj)) SWIG_fail;
13109 {
13110 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13111 if ( tmp1 == NULL )
13112 return NULL;
13113 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13114 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13115 }
13116 {
13117 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13118 if ( tmp3 == NULL )
13119 return NULL;
13120 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13121 {
13122 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13123 return NULL;
13124 }
13125 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13126 }
13127 {
13128 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
13129 if ( tmp4 == NULL )
13130 return NULL;
13131 if ( PyArray_DIMS( tmp4 )[0] != Alen )
13132 {
13133 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13134 return NULL;
13135 }
13136 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
13137 }
13138 res5 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf5, NULL, &alloc5);
13139 if (!SWIG_IsOK(res5)) {
13140 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
13141 }
13142 arg5 = (char *)(buf5);
13143 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
13144 resultobj = SWIG_Py_Void();
13145 {
13146 Py_CLEAR( tmp1 );
13147 }
13148 {
13149 Py_CLEAR( tmp3 );
13150 }
13151 {
13152 Py_CLEAR( tmp4 );
13153 }
13154 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13155 return resultobj;
13156fail:
13157 {
13158 Py_CLEAR( tmp1 );
13159 }
13160 {
13161 Py_CLEAR( tmp3 );
13162 }
13163 {
13164 Py_CLEAR( tmp4 );
13165 }
13166 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13167 return NULL;
13168}
13169
13170
13171SWIGINTERN PyObject *_wrap_plstripa(PyObject *self, PyObject *args) {
13172 PyObject *resultobj = 0;
13173 PLINT arg1 ;
13174 PLINT arg2 ;
13175 PLFLT arg3 ;
13176 PLFLT arg4 ;
13177 int val1 ;
13178 int ecode1 = 0 ;
13179 int val2 ;
13180 int ecode2 = 0 ;
13181 double val3 ;
13182 int ecode3 = 0 ;
13183 double val4 ;
13184 int ecode4 = 0 ;
13185 PyObject *swig_obj[4] ;
13186
13187 (void)self;
13188 if (!SWIG_Python_UnpackTuple(args, "plstripa", 4, 4, swig_obj)) SWIG_fail;
13189 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13190 if (!SWIG_IsOK(ecode1)) {
13191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
13192 }
13193 arg1 = (PLINT)(val1);
13194 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13195 if (!SWIG_IsOK(ecode2)) {
13196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
13197 }
13198 arg2 = (PLINT)(val2);
13199 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13200 if (!SWIG_IsOK(ecode3)) {
13201 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
13202 }
13203 arg3 = (PLFLT)(val3);
13204 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13205 if (!SWIG_IsOK(ecode4)) {
13206 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
13207 }
13208 arg4 = (PLFLT)(val4);
13209 plstripa(arg1,arg2,arg3,arg4);
13210 resultobj = SWIG_Py_Void();
13211 return resultobj;
13212fail:
13213 return NULL;
13214}
13215
13216
13217SWIGINTERN PyObject *_wrap_plstripc(PyObject *self, PyObject *args) {
13218 PyObject *resultobj = 0;
13219 PLINT *arg1 = 0 ;
13220 char *arg2 = 0 ;
13221 char *arg3 = 0 ;
13222 PLFLT arg4 ;
13223 PLFLT arg5 ;
13224 PLFLT arg6 ;
13225 PLFLT arg7 ;
13226 PLFLT arg8 ;
13227 PLFLT arg9 ;
13228 PLFLT arg10 ;
13229 PLBOOL arg11 ;
13230 PLBOOL arg12 ;
13231 PLINT arg13 ;
13232 PLINT arg14 ;
13233 PLINT *arg15 = 0 ;
13234 PLINT *arg16 = 0 ;
13235 char **arg17 = (char **)0 ;
13236 char *arg18 = 0 ;
13237 char *arg19 = 0 ;
13238 char *arg20 = 0 ;
13239 PLINT temp1 ;
13240 int res1 = SWIG_TMPOBJ ;
13241 int res2 ;
13242 char *buf2 = 0 ;
13243 int alloc2 = 0 ;
13244 int res3 ;
13245 char *buf3 = 0 ;
13246 int alloc3 = 0 ;
13247 double val4 ;
13248 int ecode4 = 0 ;
13249 double val5 ;
13250 int ecode5 = 0 ;
13251 double val6 ;
13252 int ecode6 = 0 ;
13253 double val7 ;
13254 int ecode7 = 0 ;
13255 double val8 ;
13256 int ecode8 = 0 ;
13257 double val9 ;
13258 int ecode9 = 0 ;
13259 double val10 ;
13260 int ecode10 = 0 ;
13261 int val11 ;
13262 int ecode11 = 0 ;
13263 int val12 ;
13264 int ecode12 = 0 ;
13265 int val13 ;
13266 int ecode13 = 0 ;
13267 int val14 ;
13268 int ecode14 = 0 ;
13269 PyArrayObject *tmp15 = NULL ;
13270 PyArrayObject *tmp16 = NULL ;
13271 char **tmp17 = NULL ;
13272 int res18 ;
13273 char *buf18 = 0 ;
13274 int alloc18 = 0 ;
13275 int res19 ;
13276 char *buf19 = 0 ;
13277 int alloc19 = 0 ;
13278 int res20 ;
13279 char *buf20 = 0 ;
13280 int alloc20 = 0 ;
13281 PyObject *swig_obj[19] ;
13282
13283 arg1 = &temp1;
13284 (void)self;
13285 if (!SWIG_Python_UnpackTuple(args, "plstripc", 19, 19, swig_obj)) SWIG_fail;
13286 res2 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf2, NULL, &alloc2);
13287 if (!SWIG_IsOK(res2)) {
13288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13289 }
13290 arg2 = (char *)(buf2);
13291 res3 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf3, NULL, &alloc3);
13292 if (!SWIG_IsOK(res3)) {
13293 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13294 }
13295 arg3 = (char *)(buf3);
13296 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
13297 if (!SWIG_IsOK(ecode4)) {
13298 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13299 }
13300 arg4 = (PLFLT)(val4);
13301 ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
13302 if (!SWIG_IsOK(ecode5)) {
13303 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13304 }
13305 arg5 = (PLFLT)(val5);
13306 ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
13307 if (!SWIG_IsOK(ecode6)) {
13308 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13309 }
13310 arg6 = (PLFLT)(val6);
13311 ecode7 = SWIG_AsVal_double(swig_obj[5], &val7);
13312 if (!SWIG_IsOK(ecode7)) {
13313 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13314 }
13315 arg7 = (PLFLT)(val7);
13316 ecode8 = SWIG_AsVal_double(swig_obj[6], &val8);
13317 if (!SWIG_IsOK(ecode8)) {
13318 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13319 }
13320 arg8 = (PLFLT)(val8);
13321 ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
13322 if (!SWIG_IsOK(ecode9)) {
13323 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13324 }
13325 arg9 = (PLFLT)(val9);
13326 ecode10 = SWIG_AsVal_double(swig_obj[8], &val10);
13327 if (!SWIG_IsOK(ecode10)) {
13328 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13329 }
13330 arg10 = (PLFLT)(val10);
13331 ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
13332 if (!SWIG_IsOK(ecode11)) {
13333 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13334 }
13335 arg11 = (PLBOOL)(val11);
13336 ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
13337 if (!SWIG_IsOK(ecode12)) {
13338 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13339 }
13340 arg12 = (PLBOOL)(val12);
13341 ecode13 = SWIG_AsVal_int(swig_obj[11], &val13);
13342 if (!SWIG_IsOK(ecode13)) {
13343 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13344 }
13345 arg13 = (PLINT)(val13);
13346 ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
13347 if (!SWIG_IsOK(ecode14)) {
13348 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13349 }
13350 arg14 = (PLINT)(val14);
13351 {
13352 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
13353 if ( tmp15 == NULL )
13354 return NULL;
13355 Alen = PyArray_DIMS( tmp15 )[0];
13356 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13357 }
13358 {
13359 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[14], NPY_PLINT, 1, 1 );
13360 if ( tmp16 == NULL )
13361 return NULL;
13362 if ( PyArray_DIMS( tmp16 )[0] != Alen )
13363 {
13364 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13365 return NULL;
13366 }
13367 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13368 }
13369 {
13370 int i;
13371 PyObject *elt, *unicode_string;
13372
13373 if ( !PySequence_Check( swig_obj[15] ) || PySequence_Size( swig_obj[15] ) != 4 )
13374 {
13375 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13376 return NULL;
13377 }
13378 if ( Alen != 4 )
13379 {
13380 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13381 return NULL;
13382 }
13383 tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13384 if ( tmp17 == NULL )
13385 return NULL;
13386 arg17 = tmp17;
13387 for ( i = 0; i < 4; i++ )
13388 {
13389 arg17[i] = NULL;
13390 elt = PySequence_Fast_GET_ITEM( swig_obj[15], i );
13391 if ( PyString_Check( elt ) )
13392 {
13393 arg17[i] = PyString_AsString( elt );
13394 }
13395 else if ( PyUnicode_Check( elt ) )
13396 {
13397 unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
13398 arg17[i] = PyBytes_AS_STRING( unicode_string );
13399 }
13400 if ( arg17[i] == NULL )
13401 {
13402 free( tmp17 );
13403 return NULL;
13404 }
13405 }
13406 }
13407 res18 = SWIG_AsCharPtrAndSize(swig_obj[16], &buf18, NULL, &alloc18);
13408 if (!SWIG_IsOK(res18)) {
13409 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13410 }
13411 arg18 = (char *)(buf18);
13412 res19 = SWIG_AsCharPtrAndSize(swig_obj[17], &buf19, NULL, &alloc19);
13413 if (!SWIG_IsOK(res19)) {
13414 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13415 }
13416 arg19 = (char *)(buf19);
13417 res20 = SWIG_AsCharPtrAndSize(swig_obj[18], &buf20, NULL, &alloc20);
13418 if (!SWIG_IsOK(res20)) {
13419 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13420 }
13421 arg20 = (char *)(buf20);
13422 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);
13423 resultobj = SWIG_Py_Void();
13424 if (SWIG_IsTmpObj(res1)) {
13425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
13426 } else {
13427 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13428 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
13429 }
13430 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13431 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13432 {
13433 Py_CLEAR( tmp15 );
13434 }
13435 {
13436 Py_CLEAR( tmp16 );
13437 }
13438 {
13439 free( tmp17 );
13440 }
13441 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13442 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13443 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13444 return resultobj;
13445fail:
13446 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13447 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13448 {
13449 Py_CLEAR( tmp15 );
13450 }
13451 {
13452 Py_CLEAR( tmp16 );
13453 }
13454 {
13455 free( tmp17 );
13456 }
13457 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13458 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13459 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13460 return NULL;
13461}
13462
13463
13464SWIGINTERN PyObject *_wrap_plstripd(PyObject *self, PyObject *args) {
13465 PyObject *resultobj = 0;
13466 PLINT arg1 ;
13467 int val1 ;
13468 int ecode1 = 0 ;
13469 PyObject *swig_obj[1] ;
13470
13471 (void)self;
13472 if (!args) SWIG_fail;
13473 swig_obj[0] = args;
13474 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13475 if (!SWIG_IsOK(ecode1)) {
13476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13477 }
13478 arg1 = (PLINT)(val1);
13479 plstripd(arg1);
13480 resultobj = SWIG_Py_Void();
13481 return resultobj;
13482fail:
13483 return NULL;
13484}
13485
13486
13487SWIGINTERN PyObject *_wrap_plstyl(PyObject *self, PyObject *args) {
13488 PyObject *resultobj = 0;
13489 PLINT arg1 ;
13490 PLINT *arg2 = 0 ;
13491 PLINT *arg3 = 0 ;
13492 PyArrayObject *tmp1 = NULL ;
13493 PyArrayObject *tmp3 = NULL ;
13494 PyObject *swig_obj[2] ;
13495
13496 (void)self;
13497 if (!SWIG_Python_UnpackTuple(args, "plstyl", 2, 2, swig_obj)) SWIG_fail;
13498 {
13499 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
13500 if ( tmp1 == NULL )
13501 return NULL;
13502 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13503 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13504 }
13505 {
13506 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
13507 if ( tmp3 == NULL )
13508 return NULL;
13509 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13510 {
13511 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13512 return NULL;
13513 }
13514 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13515 }
13516 plstyl(arg1,(int const *)arg2,(int const *)arg3);
13517 resultobj = SWIG_Py_Void();
13518 {
13519 Py_CLEAR( tmp1 );
13520 }
13521 {
13522 Py_CLEAR( tmp3 );
13523 }
13524 return resultobj;
13525fail:
13526 {
13527 Py_CLEAR( tmp1 );
13528 }
13529 {
13530 Py_CLEAR( tmp3 );
13531 }
13532 return NULL;
13533}
13534
13535
13536SWIGINTERN PyObject *_wrap_plsvect(PyObject *self, PyObject *args) {
13537 PyObject *resultobj = 0;
13538 PLFLT *arg1 = 0 ;
13539 PLFLT *arg2 = 0 ;
13540 PLINT arg3 ;
13541 PLBOOL arg4 ;
13542 PyArrayObject *tmp1 = NULL ;
13543 PyArrayObject *tmp2 = NULL ;
13544 int val4 ;
13545 int ecode4 = 0 ;
13546 PyObject *swig_obj[3] ;
13547
13548 (void)self;
13549 if (!SWIG_Python_UnpackTuple(args, "plsvect", 3, 3, swig_obj)) SWIG_fail;
13550 {
13551 if ( swig_obj[0] != Py_None )
13552 {
13553 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13554 if ( tmp1 == NULL )
13555 return NULL;
13556 Alen = PyArray_DIMS( tmp1 )[0];
13557 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13558 }
13559 else
13560 {
13561 arg1 = NULL;
13562 Alen = 0;
13563 }
13564 }
13565 {
13566 if ( swig_obj[1] != Py_None )
13567 {
13568 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13569 if ( tmp2 == NULL )
13570 return NULL;
13571 if ( PyArray_DIMS( tmp2 )[0] != Alen )
13572 {
13573 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13574 return NULL;
13575 }
13576 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13577 arg3 = PyArray_DIMS( tmp2 )[0];
13578 }
13579 else
13580 {
13581 arg2 = NULL;
13582 arg3 = 0;
13583 }
13584 }
13585 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13586 if (!SWIG_IsOK(ecode4)) {
13587 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13588 }
13589 arg4 = (PLBOOL)(val4);
13590 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13591 resultobj = SWIG_Py_Void();
13592 {
13593 Py_CLEAR( tmp1 );
13594 }
13595 {
13596 Py_CLEAR( tmp2 );
13597 }
13598 return resultobj;
13599fail:
13600 {
13601 Py_CLEAR( tmp1 );
13602 }
13603 {
13604 Py_CLEAR( tmp2 );
13605 }
13606 return NULL;
13607}
13608
13609
13610SWIGINTERN PyObject *_wrap_plsvpa(PyObject *self, PyObject *args) {
13611 PyObject *resultobj = 0;
13612 PLFLT arg1 ;
13613 PLFLT arg2 ;
13614 PLFLT arg3 ;
13615 PLFLT arg4 ;
13616 double val1 ;
13617 int ecode1 = 0 ;
13618 double val2 ;
13619 int ecode2 = 0 ;
13620 double val3 ;
13621 int ecode3 = 0 ;
13622 double val4 ;
13623 int ecode4 = 0 ;
13624 PyObject *swig_obj[4] ;
13625
13626 (void)self;
13627 if (!SWIG_Python_UnpackTuple(args, "plsvpa", 4, 4, swig_obj)) SWIG_fail;
13628 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13629 if (!SWIG_IsOK(ecode1)) {
13630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13631 }
13632 arg1 = (PLFLT)(val1);
13633 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13634 if (!SWIG_IsOK(ecode2)) {
13635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13636 }
13637 arg2 = (PLFLT)(val2);
13638 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13639 if (!SWIG_IsOK(ecode3)) {
13640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13641 }
13642 arg3 = (PLFLT)(val3);
13643 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13644 if (!SWIG_IsOK(ecode4)) {
13645 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13646 }
13647 arg4 = (PLFLT)(val4);
13648 plsvpa(arg1,arg2,arg3,arg4);
13649 resultobj = SWIG_Py_Void();
13650 return resultobj;
13651fail:
13652 return NULL;
13653}
13654
13655
13656SWIGINTERN PyObject *_wrap_plsxax(PyObject *self, PyObject *args) {
13657 PyObject *resultobj = 0;
13658 PLINT arg1 ;
13659 PLINT arg2 ;
13660 int val1 ;
13661 int ecode1 = 0 ;
13662 int val2 ;
13663 int ecode2 = 0 ;
13664 PyObject *swig_obj[2] ;
13665
13666 (void)self;
13667 if (!SWIG_Python_UnpackTuple(args, "plsxax", 2, 2, swig_obj)) SWIG_fail;
13668 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13669 if (!SWIG_IsOK(ecode1)) {
13670 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13671 }
13672 arg1 = (PLINT)(val1);
13673 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13674 if (!SWIG_IsOK(ecode2)) {
13675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13676 }
13677 arg2 = (PLINT)(val2);
13678 plsxax(arg1,arg2);
13679 resultobj = SWIG_Py_Void();
13680 return resultobj;
13681fail:
13682 return NULL;
13683}
13684
13685
13686SWIGINTERN PyObject *_wrap_plsyax(PyObject *self, PyObject *args) {
13687 PyObject *resultobj = 0;
13688 PLINT arg1 ;
13689 PLINT arg2 ;
13690 int val1 ;
13691 int ecode1 = 0 ;
13692 int val2 ;
13693 int ecode2 = 0 ;
13694 PyObject *swig_obj[2] ;
13695
13696 (void)self;
13697 if (!SWIG_Python_UnpackTuple(args, "plsyax", 2, 2, swig_obj)) SWIG_fail;
13698 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13699 if (!SWIG_IsOK(ecode1)) {
13700 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13701 }
13702 arg1 = (PLINT)(val1);
13703 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13704 if (!SWIG_IsOK(ecode2)) {
13705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13706 }
13707 arg2 = (PLINT)(val2);
13708 plsyax(arg1,arg2);
13709 resultobj = SWIG_Py_Void();
13710 return resultobj;
13711fail:
13712 return NULL;
13713}
13714
13715
13716SWIGINTERN PyObject *_wrap_plsym(PyObject *self, PyObject *args) {
13717 PyObject *resultobj = 0;
13718 PLINT arg1 ;
13719 PLFLT *arg2 = 0 ;
13720 PLFLT *arg3 = 0 ;
13721 PLINT arg4 ;
13722 PyArrayObject *tmp1 = NULL ;
13723 PyArrayObject *tmp3 = NULL ;
13724 int val4 ;
13725 int ecode4 = 0 ;
13726 PyObject *swig_obj[3] ;
13727
13728 (void)self;
13729 if (!SWIG_Python_UnpackTuple(args, "plsym", 3, 3, swig_obj)) SWIG_fail;
13730 {
13731 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13732 if ( tmp1 == NULL )
13733 return NULL;
13734 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13735 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13736 }
13737 {
13738 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13739 if ( tmp3 == NULL )
13740 return NULL;
13741 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13742 {
13743 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13744 return NULL;
13745 }
13746 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13747 }
13748 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13749 if (!SWIG_IsOK(ecode4)) {
13750 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13751 }
13752 arg4 = (PLINT)(val4);
13753 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13754 resultobj = SWIG_Py_Void();
13755 {
13756 Py_CLEAR( tmp1 );
13757 }
13758 {
13759 Py_CLEAR( tmp3 );
13760 }
13761 return resultobj;
13762fail:
13763 {
13764 Py_CLEAR( tmp1 );
13765 }
13766 {
13767 Py_CLEAR( tmp3 );
13768 }
13769 return NULL;
13770}
13771
13772
13773SWIGINTERN PyObject *_wrap_plszax(PyObject *self, PyObject *args) {
13774 PyObject *resultobj = 0;
13775 PLINT arg1 ;
13776 PLINT arg2 ;
13777 int val1 ;
13778 int ecode1 = 0 ;
13779 int val2 ;
13780 int ecode2 = 0 ;
13781 PyObject *swig_obj[2] ;
13782
13783 (void)self;
13784 if (!SWIG_Python_UnpackTuple(args, "plszax", 2, 2, swig_obj)) SWIG_fail;
13785 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13786 if (!SWIG_IsOK(ecode1)) {
13787 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13788 }
13789 arg1 = (PLINT)(val1);
13790 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13791 if (!SWIG_IsOK(ecode2)) {
13792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13793 }
13794 arg2 = (PLINT)(val2);
13795 plszax(arg1,arg2);
13796 resultobj = SWIG_Py_Void();
13797 return resultobj;
13798fail:
13799 return NULL;
13800}
13801
13802
13803SWIGINTERN PyObject *_wrap_pltext(PyObject *self, PyObject *args) {
13804 PyObject *resultobj = 0;
13805
13806 (void)self;
13807 if (!SWIG_Python_UnpackTuple(args, "pltext", 0, 0, 0)) SWIG_fail;
13808 pltext();
13809 resultobj = SWIG_Py_Void();
13810 return resultobj;
13811fail:
13812 return NULL;
13813}
13814
13815
13816SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *self, PyObject *args) {
13817 PyObject *resultobj = 0;
13818 char *arg1 = 0 ;
13819 int res1 ;
13820 char *buf1 = 0 ;
13821 int alloc1 = 0 ;
13822 PyObject *swig_obj[1] ;
13823
13824 (void)self;
13825 if (!args) SWIG_fail;
13826 swig_obj[0] = args;
13827 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13828 if (!SWIG_IsOK(res1)) {
13829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13830 }
13831 arg1 = (char *)(buf1);
13832 pltimefmt((char const *)arg1);
13833 resultobj = SWIG_Py_Void();
13834 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13835 return resultobj;
13836fail:
13837 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13838 return NULL;
13839}
13840
13841
13842SWIGINTERN PyObject *_wrap_plvasp(PyObject *self, PyObject *args) {
13843 PyObject *resultobj = 0;
13844 PLFLT arg1 ;
13845 double val1 ;
13846 int ecode1 = 0 ;
13847 PyObject *swig_obj[1] ;
13848
13849 (void)self;
13850 if (!args) SWIG_fail;
13851 swig_obj[0] = args;
13852 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13853 if (!SWIG_IsOK(ecode1)) {
13854 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13855 }
13856 arg1 = (PLFLT)(val1);
13857 plvasp(arg1);
13858 resultobj = SWIG_Py_Void();
13859 return resultobj;
13860fail:
13861 return NULL;
13862}
13863
13864
13865SWIGINTERN PyObject *_wrap_plvect(PyObject *self, PyObject *args) {
13866 PyObject *resultobj = 0;
13867 PLFLT **arg1 = 0 ;
13868 PLFLT **arg2 = 0 ;
13869 PLINT arg3 ;
13870 PLINT arg4 ;
13871 PLFLT arg5 ;
13872 pltr_func arg6 = 0 ;
13873 PLPointer arg7 = 0 ;
13874 PyArrayObject *tmp1 = NULL ;
13875 PyArrayObject *tmp2 = NULL ;
13876 double val5 ;
13877 int ecode5 = 0 ;
13878 PyObject *swig_obj[5] ;
13879
13880 {
13881 python_pltr = 0;
13882 arg6 = NULL;
13883 }
13884 {
13885 arg7 = NULL;
13886 }
13887 (void)self;
13888 if (!SWIG_Python_UnpackTuple(args, "plvect", 3, 5, swig_obj)) SWIG_fail;
13889 {
13890 int i, size;
13891 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
13892 if ( tmp1 == NULL )
13893 return NULL;
13894 Xlen = PyArray_DIMS( tmp1 )[0];
13895 Ylen = PyArray_DIMS( tmp1 )[1];
13896 size = Ylen;
13897 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13898 for ( i = 0; i < Xlen; i++ )
13899 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13900 }
13901 {
13902 int i, size;
13903 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 2, 2 );
13904 if ( tmp2 == NULL )
13905 return NULL;
13906 if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13907 {
13908 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13909 return NULL;
13910 }
13911 arg3 = PyArray_DIMS( tmp2 )[0];
13912 arg4 = PyArray_DIMS( tmp2 )[1];
13913 size = arg4;
13914 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13915 for ( i = 0; i < arg3; i++ )
13916 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13917 }
13918 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
13919 if (!SWIG_IsOK(ecode5)) {
13920 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13921 }
13922 arg5 = (PLFLT)(val5);
13923 if (swig_obj[3]) {
13924 {
13925 // it must be a callable or None
13926 if ( swig_obj[3] == Py_None )
13927 {
13928 arg6 = NULL;
13929 }
13930 else
13931 {
13932 if ( !PyCallable_Check( (PyObject *) swig_obj[3] ) )
13933 {
13934 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13935 return NULL;
13936 }
13937 arg6 = marshal_pltr( swig_obj[3] );
13938 }
13939 }
13940 }
13941 if (swig_obj[4]) {
13942 {
13943 if ( swig_obj[4] == Py_None )
13944 arg7 = NULL;
13945 else
13946 {
13947 arg7 = marshal_PLPointer( swig_obj[4], 0 );
13948 }
13949 }
13950 }
13951 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13952 resultobj = SWIG_Py_Void();
13953 {
13954 Py_CLEAR( tmp1 );
13955 free( arg1 );
13956 }
13957 {
13958 Py_CLEAR( tmp2 );
13959 free( arg2 );
13960 }
13961 {
13962 cleanup_pltr();
13963 }
13964 {
13966 }
13967 return resultobj;
13968fail:
13969 {
13970 Py_CLEAR( tmp1 );
13971 free( arg1 );
13972 }
13973 {
13974 Py_CLEAR( tmp2 );
13975 free( arg2 );
13976 }
13977 {
13978 cleanup_pltr();
13979 }
13980 {
13982 }
13983 return NULL;
13984}
13985
13986
13987SWIGINTERN PyObject *_wrap_plvpas(PyObject *self, PyObject *args) {
13988 PyObject *resultobj = 0;
13989 PLFLT arg1 ;
13990 PLFLT arg2 ;
13991 PLFLT arg3 ;
13992 PLFLT arg4 ;
13993 PLFLT arg5 ;
13994 double val1 ;
13995 int ecode1 = 0 ;
13996 double val2 ;
13997 int ecode2 = 0 ;
13998 double val3 ;
13999 int ecode3 = 0 ;
14000 double val4 ;
14001 int ecode4 = 0 ;
14002 double val5 ;
14003 int ecode5 = 0 ;
14004 PyObject *swig_obj[5] ;
14005
14006 (void)self;
14007 if (!SWIG_Python_UnpackTuple(args, "plvpas", 5, 5, swig_obj)) SWIG_fail;
14008 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14009 if (!SWIG_IsOK(ecode1)) {
14010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
14011 }
14012 arg1 = (PLFLT)(val1);
14013 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14014 if (!SWIG_IsOK(ecode2)) {
14015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
14016 }
14017 arg2 = (PLFLT)(val2);
14018 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14019 if (!SWIG_IsOK(ecode3)) {
14020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
14021 }
14022 arg3 = (PLFLT)(val3);
14023 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14024 if (!SWIG_IsOK(ecode4)) {
14025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
14026 }
14027 arg4 = (PLFLT)(val4);
14028 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14029 if (!SWIG_IsOK(ecode5)) {
14030 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
14031 }
14032 arg5 = (PLFLT)(val5);
14033 plvpas(arg1,arg2,arg3,arg4,arg5);
14034 resultobj = SWIG_Py_Void();
14035 return resultobj;
14036fail:
14037 return NULL;
14038}
14039
14040
14041SWIGINTERN PyObject *_wrap_plvpor(PyObject *self, PyObject *args) {
14042 PyObject *resultobj = 0;
14043 PLFLT arg1 ;
14044 PLFLT arg2 ;
14045 PLFLT arg3 ;
14046 PLFLT arg4 ;
14047 double val1 ;
14048 int ecode1 = 0 ;
14049 double val2 ;
14050 int ecode2 = 0 ;
14051 double val3 ;
14052 int ecode3 = 0 ;
14053 double val4 ;
14054 int ecode4 = 0 ;
14055 PyObject *swig_obj[4] ;
14056
14057 (void)self;
14058 if (!SWIG_Python_UnpackTuple(args, "plvpor", 4, 4, swig_obj)) SWIG_fail;
14059 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14060 if (!SWIG_IsOK(ecode1)) {
14061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
14062 }
14063 arg1 = (PLFLT)(val1);
14064 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14065 if (!SWIG_IsOK(ecode2)) {
14066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
14067 }
14068 arg2 = (PLFLT)(val2);
14069 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14070 if (!SWIG_IsOK(ecode3)) {
14071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
14072 }
14073 arg3 = (PLFLT)(val3);
14074 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14075 if (!SWIG_IsOK(ecode4)) {
14076 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
14077 }
14078 arg4 = (PLFLT)(val4);
14079 plvpor(arg1,arg2,arg3,arg4);
14080 resultobj = SWIG_Py_Void();
14081 return resultobj;
14082fail:
14083 return NULL;
14084}
14085
14086
14087SWIGINTERN PyObject *_wrap_plvsta(PyObject *self, PyObject *args) {
14088 PyObject *resultobj = 0;
14089
14090 (void)self;
14091 if (!SWIG_Python_UnpackTuple(args, "plvsta", 0, 0, 0)) SWIG_fail;
14092 plvsta();
14093 resultobj = SWIG_Py_Void();
14094 return resultobj;
14095fail:
14096 return NULL;
14097}
14098
14099
14100SWIGINTERN PyObject *_wrap_plw3d(PyObject *self, PyObject *args) {
14101 PyObject *resultobj = 0;
14102 PLFLT arg1 ;
14103 PLFLT arg2 ;
14104 PLFLT arg3 ;
14105 PLFLT arg4 ;
14106 PLFLT arg5 ;
14107 PLFLT arg6 ;
14108 PLFLT arg7 ;
14109 PLFLT arg8 ;
14110 PLFLT arg9 ;
14111 PLFLT arg10 ;
14112 PLFLT arg11 ;
14113 double val1 ;
14114 int ecode1 = 0 ;
14115 double val2 ;
14116 int ecode2 = 0 ;
14117 double val3 ;
14118 int ecode3 = 0 ;
14119 double val4 ;
14120 int ecode4 = 0 ;
14121 double val5 ;
14122 int ecode5 = 0 ;
14123 double val6 ;
14124 int ecode6 = 0 ;
14125 double val7 ;
14126 int ecode7 = 0 ;
14127 double val8 ;
14128 int ecode8 = 0 ;
14129 double val9 ;
14130 int ecode9 = 0 ;
14131 double val10 ;
14132 int ecode10 = 0 ;
14133 double val11 ;
14134 int ecode11 = 0 ;
14135 PyObject *swig_obj[11] ;
14136
14137 (void)self;
14138 if (!SWIG_Python_UnpackTuple(args, "plw3d", 11, 11, swig_obj)) SWIG_fail;
14139 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14140 if (!SWIG_IsOK(ecode1)) {
14141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
14142 }
14143 arg1 = (PLFLT)(val1);
14144 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14145 if (!SWIG_IsOK(ecode2)) {
14146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
14147 }
14148 arg2 = (PLFLT)(val2);
14149 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14150 if (!SWIG_IsOK(ecode3)) {
14151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
14152 }
14153 arg3 = (PLFLT)(val3);
14154 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14155 if (!SWIG_IsOK(ecode4)) {
14156 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
14157 }
14158 arg4 = (PLFLT)(val4);
14159 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14160 if (!SWIG_IsOK(ecode5)) {
14161 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
14162 }
14163 arg5 = (PLFLT)(val5);
14164 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14165 if (!SWIG_IsOK(ecode6)) {
14166 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
14167 }
14168 arg6 = (PLFLT)(val6);
14169 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14170 if (!SWIG_IsOK(ecode7)) {
14171 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
14172 }
14173 arg7 = (PLFLT)(val7);
14174 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14175 if (!SWIG_IsOK(ecode8)) {
14176 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
14177 }
14178 arg8 = (PLFLT)(val8);
14179 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14180 if (!SWIG_IsOK(ecode9)) {
14181 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
14182 }
14183 arg9 = (PLFLT)(val9);
14184 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14185 if (!SWIG_IsOK(ecode10)) {
14186 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
14187 }
14188 arg10 = (PLFLT)(val10);
14189 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
14190 if (!SWIG_IsOK(ecode11)) {
14191 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
14192 }
14193 arg11 = (PLFLT)(val11);
14194 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14195 resultobj = SWIG_Py_Void();
14196 return resultobj;
14197fail:
14198 return NULL;
14199}
14200
14201
14202SWIGINTERN PyObject *_wrap_plwidth(PyObject *self, PyObject *args) {
14203 PyObject *resultobj = 0;
14204 PLFLT arg1 ;
14205 double val1 ;
14206 int ecode1 = 0 ;
14207 PyObject *swig_obj[1] ;
14208
14209 (void)self;
14210 if (!args) SWIG_fail;
14211 swig_obj[0] = args;
14212 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14213 if (!SWIG_IsOK(ecode1)) {
14214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
14215 }
14216 arg1 = (PLFLT)(val1);
14217 plwidth(arg1);
14218 resultobj = SWIG_Py_Void();
14219 return resultobj;
14220fail:
14221 return NULL;
14222}
14223
14224
14225SWIGINTERN PyObject *_wrap_plwind(PyObject *self, PyObject *args) {
14226 PyObject *resultobj = 0;
14227 PLFLT arg1 ;
14228 PLFLT arg2 ;
14229 PLFLT arg3 ;
14230 PLFLT arg4 ;
14231 double val1 ;
14232 int ecode1 = 0 ;
14233 double val2 ;
14234 int ecode2 = 0 ;
14235 double val3 ;
14236 int ecode3 = 0 ;
14237 double val4 ;
14238 int ecode4 = 0 ;
14239 PyObject *swig_obj[4] ;
14240
14241 (void)self;
14242 if (!SWIG_Python_UnpackTuple(args, "plwind", 4, 4, swig_obj)) SWIG_fail;
14243 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14244 if (!SWIG_IsOK(ecode1)) {
14245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14246 }
14247 arg1 = (PLFLT)(val1);
14248 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14249 if (!SWIG_IsOK(ecode2)) {
14250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14251 }
14252 arg2 = (PLFLT)(val2);
14253 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14254 if (!SWIG_IsOK(ecode3)) {
14255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14256 }
14257 arg3 = (PLFLT)(val3);
14258 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14259 if (!SWIG_IsOK(ecode4)) {
14260 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14261 }
14262 arg4 = (PLFLT)(val4);
14263 plwind(arg1,arg2,arg3,arg4);
14264 resultobj = SWIG_Py_Void();
14265 return resultobj;
14266fail:
14267 return NULL;
14268}
14269
14270
14271SWIGINTERN PyObject *_wrap_plxormod(PyObject *self, PyObject *args) {
14272 PyObject *resultobj = 0;
14273 PLBOOL arg1 ;
14274 PLBOOL *arg2 = 0 ;
14275 int val1 ;
14276 int ecode1 = 0 ;
14277 PLBOOL temp2 ;
14278 int res2 = SWIG_TMPOBJ ;
14279 PyObject *swig_obj[1] ;
14280
14281 arg2 = &temp2;
14282 (void)self;
14283 if (!args) SWIG_fail;
14284 swig_obj[0] = args;
14285 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
14286 if (!SWIG_IsOK(ecode1)) {
14287 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14288 }
14289 arg1 = (PLBOOL)(val1);
14290 plxormod(arg1,arg2);
14291 resultobj = SWIG_Py_Void();
14292 if (SWIG_IsTmpObj(res2)) {
14293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
14294 } else {
14295 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14296 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
14297 }
14298 return resultobj;
14299fail:
14300 return NULL;
14301}
14302
14303
14304SWIGINTERN PyObject *_wrap_plmap(PyObject *self, PyObject *args) {
14305 PyObject *resultobj = 0;
14306 mapform_func arg1 = 0 ;
14307 char *arg2 = 0 ;
14308 PLFLT arg3 ;
14309 PLFLT arg4 ;
14310 PLFLT arg5 ;
14311 PLFLT arg6 ;
14312 int res2 ;
14313 char *buf2 = 0 ;
14314 int alloc2 = 0 ;
14315 double val3 ;
14316 int ecode3 = 0 ;
14317 double val4 ;
14318 int ecode4 = 0 ;
14319 double val5 ;
14320 int ecode5 = 0 ;
14321 double val6 ;
14322 int ecode6 = 0 ;
14323 PyObject *swig_obj[6] ;
14324
14325 (void)self;
14326 if (!SWIG_Python_UnpackTuple(args, "plmap", 6, 6, swig_obj)) SWIG_fail;
14327 {
14328 // it must be a callable or none
14329 if ( swig_obj[0] == Py_None )
14330 {
14331 arg1 = NULL;
14332 }
14333 else
14334 {
14335 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14336 {
14337 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14338 return NULL;
14339 }
14340 arg1 = marshal_mapform( swig_obj[0] );
14341 }
14342 }
14343 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14344 if (!SWIG_IsOK(res2)) {
14345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14346 }
14347 arg2 = (char *)(buf2);
14348 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14349 if (!SWIG_IsOK(ecode3)) {
14350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14351 }
14352 arg3 = (PLFLT)(val3);
14353 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14354 if (!SWIG_IsOK(ecode4)) {
14355 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14356 }
14357 arg4 = (PLFLT)(val4);
14358 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14359 if (!SWIG_IsOK(ecode5)) {
14360 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14361 }
14362 arg5 = (PLFLT)(val5);
14363 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14364 if (!SWIG_IsOK(ecode6)) {
14365 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14366 }
14367 arg6 = (PLFLT)(val6);
14368 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14369 resultobj = SWIG_Py_Void();
14370 {
14372 }
14373 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14374 return resultobj;
14375fail:
14376 {
14378 }
14379 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14380 return NULL;
14381}
14382
14383
14384SWIGINTERN PyObject *_wrap_plmapline(PyObject *self, PyObject *args) {
14385 PyObject *resultobj = 0;
14386 mapform_func arg1 = 0 ;
14387 char *arg2 = 0 ;
14388 PLFLT arg3 ;
14389 PLFLT arg4 ;
14390 PLFLT arg5 ;
14391 PLFLT arg6 ;
14392 PLINT *arg7 = 0 ;
14393 PLINT arg8 ;
14394 int res2 ;
14395 char *buf2 = 0 ;
14396 int alloc2 = 0 ;
14397 double val3 ;
14398 int ecode3 = 0 ;
14399 double val4 ;
14400 int ecode4 = 0 ;
14401 double val5 ;
14402 int ecode5 = 0 ;
14403 double val6 ;
14404 int ecode6 = 0 ;
14405 PyArrayObject *tmp7 = NULL ;
14406 PyObject *swig_obj[7] ;
14407
14408 (void)self;
14409 if (!SWIG_Python_UnpackTuple(args, "plmapline", 7, 7, swig_obj)) SWIG_fail;
14410 {
14411 // it must be a callable or none
14412 if ( swig_obj[0] == Py_None )
14413 {
14414 arg1 = NULL;
14415 }
14416 else
14417 {
14418 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14419 {
14420 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14421 return NULL;
14422 }
14423 arg1 = marshal_mapform( swig_obj[0] );
14424 }
14425 }
14426 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14427 if (!SWIG_IsOK(res2)) {
14428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
14429 }
14430 arg2 = (char *)(buf2);
14431 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14432 if (!SWIG_IsOK(ecode3)) {
14433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
14434 }
14435 arg3 = (PLFLT)(val3);
14436 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14437 if (!SWIG_IsOK(ecode4)) {
14438 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
14439 }
14440 arg4 = (PLFLT)(val4);
14441 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14442 if (!SWIG_IsOK(ecode5)) {
14443 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
14444 }
14445 arg5 = (PLFLT)(val5);
14446 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14447 if (!SWIG_IsOK(ecode6)) {
14448 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14449 }
14450 arg6 = (PLFLT)(val6);
14451 {
14452 if ( swig_obj[6] != Py_None )
14453 {
14454 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14455 if ( tmp7 == NULL )
14456 return NULL;
14457 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14458 arg8 = PyArray_DIMS( tmp7 )[0];
14459 }
14460 else
14461 {
14462 arg7 = NULL;
14463 arg8 = 0;
14464 }
14465 }
14466 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14467 resultobj = SWIG_Py_Void();
14468 {
14470 }
14471 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14472 {
14473 Py_CLEAR( tmp7 );
14474 }
14475 return resultobj;
14476fail:
14477 {
14479 }
14480 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14481 {
14482 Py_CLEAR( tmp7 );
14483 }
14484 return NULL;
14485}
14486
14487
14488SWIGINTERN PyObject *_wrap_plmapstring(PyObject *self, PyObject *args) {
14489 PyObject *resultobj = 0;
14490 mapform_func arg1 = 0 ;
14491 char *arg2 = 0 ;
14492 char *arg3 = 0 ;
14493 PLFLT arg4 ;
14494 PLFLT arg5 ;
14495 PLFLT arg6 ;
14496 PLFLT arg7 ;
14497 PLINT *arg8 = 0 ;
14498 PLINT arg9 ;
14499 int res2 ;
14500 char *buf2 = 0 ;
14501 int alloc2 = 0 ;
14502 int res3 ;
14503 char *buf3 = 0 ;
14504 int alloc3 = 0 ;
14505 double val4 ;
14506 int ecode4 = 0 ;
14507 double val5 ;
14508 int ecode5 = 0 ;
14509 double val6 ;
14510 int ecode6 = 0 ;
14511 double val7 ;
14512 int ecode7 = 0 ;
14513 PyArrayObject *tmp8 = NULL ;
14514 PyObject *swig_obj[8] ;
14515
14516 (void)self;
14517 if (!SWIG_Python_UnpackTuple(args, "plmapstring", 8, 8, swig_obj)) SWIG_fail;
14518 {
14519 // it must be a callable or none
14520 if ( swig_obj[0] == Py_None )
14521 {
14522 arg1 = NULL;
14523 }
14524 else
14525 {
14526 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14527 {
14528 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14529 return NULL;
14530 }
14531 arg1 = marshal_mapform( swig_obj[0] );
14532 }
14533 }
14534 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14535 if (!SWIG_IsOK(res2)) {
14536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14537 }
14538 arg2 = (char *)(buf2);
14539 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
14540 if (!SWIG_IsOK(res3)) {
14541 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14542 }
14543 arg3 = (char *)(buf3);
14544 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14545 if (!SWIG_IsOK(ecode4)) {
14546 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14547 }
14548 arg4 = (PLFLT)(val4);
14549 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14550 if (!SWIG_IsOK(ecode5)) {
14551 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14552 }
14553 arg5 = (PLFLT)(val5);
14554 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14555 if (!SWIG_IsOK(ecode6)) {
14556 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14557 }
14558 arg6 = (PLFLT)(val6);
14559 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14560 if (!SWIG_IsOK(ecode7)) {
14561 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14562 }
14563 arg7 = (PLFLT)(val7);
14564 {
14565 if ( swig_obj[7] != Py_None )
14566 {
14567 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
14568 if ( tmp8 == NULL )
14569 return NULL;
14570 arg8 = (PLINT *) PyArray_DATA( tmp8 );
14571 arg9 = PyArray_DIMS( tmp8 )[0];
14572 }
14573 else
14574 {
14575 arg8 = NULL;
14576 arg9 = 0;
14577 }
14578 }
14579 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14580 resultobj = SWIG_Py_Void();
14581 {
14583 }
14584 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14585 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14586 {
14587 Py_CLEAR( tmp8 );
14588 }
14589 return resultobj;
14590fail:
14591 {
14593 }
14594 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14595 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14596 {
14597 Py_CLEAR( tmp8 );
14598 }
14599 return NULL;
14600}
14601
14602
14603SWIGINTERN PyObject *_wrap_plmaptex(PyObject *self, PyObject *args) {
14604 PyObject *resultobj = 0;
14605 mapform_func arg1 = 0 ;
14606 char *arg2 = 0 ;
14607 PLFLT arg3 ;
14608 PLFLT arg4 ;
14609 PLFLT arg5 ;
14610 char *arg6 = 0 ;
14611 PLFLT arg7 ;
14612 PLFLT arg8 ;
14613 PLFLT arg9 ;
14614 PLFLT arg10 ;
14615 PLINT arg11 ;
14616 int res2 ;
14617 char *buf2 = 0 ;
14618 int alloc2 = 0 ;
14619 double val3 ;
14620 int ecode3 = 0 ;
14621 double val4 ;
14622 int ecode4 = 0 ;
14623 double val5 ;
14624 int ecode5 = 0 ;
14625 int res6 ;
14626 char *buf6 = 0 ;
14627 int alloc6 = 0 ;
14628 double val7 ;
14629 int ecode7 = 0 ;
14630 double val8 ;
14631 int ecode8 = 0 ;
14632 double val9 ;
14633 int ecode9 = 0 ;
14634 double val10 ;
14635 int ecode10 = 0 ;
14636 int val11 ;
14637 int ecode11 = 0 ;
14638 PyObject *swig_obj[11] ;
14639
14640 (void)self;
14641 if (!SWIG_Python_UnpackTuple(args, "plmaptex", 11, 11, swig_obj)) SWIG_fail;
14642 {
14643 // it must be a callable or none
14644 if ( swig_obj[0] == Py_None )
14645 {
14646 arg1 = NULL;
14647 }
14648 else
14649 {
14650 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14651 {
14652 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14653 return NULL;
14654 }
14655 arg1 = marshal_mapform( swig_obj[0] );
14656 }
14657 }
14658 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14659 if (!SWIG_IsOK(res2)) {
14660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14661 }
14662 arg2 = (char *)(buf2);
14663 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14664 if (!SWIG_IsOK(ecode3)) {
14665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14666 }
14667 arg3 = (PLFLT)(val3);
14668 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14669 if (!SWIG_IsOK(ecode4)) {
14670 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14671 }
14672 arg4 = (PLFLT)(val4);
14673 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14674 if (!SWIG_IsOK(ecode5)) {
14675 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14676 }
14677 arg5 = (PLFLT)(val5);
14678 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
14679 if (!SWIG_IsOK(res6)) {
14680 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14681 }
14682 arg6 = (char *)(buf6);
14683 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14684 if (!SWIG_IsOK(ecode7)) {
14685 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14686 }
14687 arg7 = (PLFLT)(val7);
14688 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14689 if (!SWIG_IsOK(ecode8)) {
14690 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14691 }
14692 arg8 = (PLFLT)(val8);
14693 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14694 if (!SWIG_IsOK(ecode9)) {
14695 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14696 }
14697 arg9 = (PLFLT)(val9);
14698 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14699 if (!SWIG_IsOK(ecode10)) {
14700 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14701 }
14702 arg10 = (PLFLT)(val10);
14703 ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
14704 if (!SWIG_IsOK(ecode11)) {
14705 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14706 }
14707 arg11 = (PLINT)(val11);
14708 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14709 resultobj = SWIG_Py_Void();
14710 {
14712 }
14713 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14714 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14715 return resultobj;
14716fail:
14717 {
14719 }
14720 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14721 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14722 return NULL;
14723}
14724
14725
14726SWIGINTERN PyObject *_wrap_plmapfill(PyObject *self, PyObject *args) {
14727 PyObject *resultobj = 0;
14728 mapform_func arg1 = 0 ;
14729 char *arg2 = 0 ;
14730 PLFLT arg3 ;
14731 PLFLT arg4 ;
14732 PLFLT arg5 ;
14733 PLFLT arg6 ;
14734 PLINT *arg7 = 0 ;
14735 PLINT arg8 ;
14736 int res2 ;
14737 char *buf2 = 0 ;
14738 int alloc2 = 0 ;
14739 double val3 ;
14740 int ecode3 = 0 ;
14741 double val4 ;
14742 int ecode4 = 0 ;
14743 double val5 ;
14744 int ecode5 = 0 ;
14745 double val6 ;
14746 int ecode6 = 0 ;
14747 PyArrayObject *tmp7 = NULL ;
14748 PyObject *swig_obj[7] ;
14749
14750 (void)self;
14751 if (!SWIG_Python_UnpackTuple(args, "plmapfill", 7, 7, swig_obj)) SWIG_fail;
14752 {
14753 // it must be a callable or none
14754 if ( swig_obj[0] == Py_None )
14755 {
14756 arg1 = NULL;
14757 }
14758 else
14759 {
14760 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14761 {
14762 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14763 return NULL;
14764 }
14765 arg1 = marshal_mapform( swig_obj[0] );
14766 }
14767 }
14768 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14769 if (!SWIG_IsOK(res2)) {
14770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14771 }
14772 arg2 = (char *)(buf2);
14773 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14774 if (!SWIG_IsOK(ecode3)) {
14775 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14776 }
14777 arg3 = (PLFLT)(val3);
14778 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14779 if (!SWIG_IsOK(ecode4)) {
14780 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14781 }
14782 arg4 = (PLFLT)(val4);
14783 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14784 if (!SWIG_IsOK(ecode5)) {
14785 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14786 }
14787 arg5 = (PLFLT)(val5);
14788 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14789 if (!SWIG_IsOK(ecode6)) {
14790 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14791 }
14792 arg6 = (PLFLT)(val6);
14793 {
14794 if ( swig_obj[6] != Py_None )
14795 {
14796 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14797 if ( tmp7 == NULL )
14798 return NULL;
14799 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14800 arg8 = PyArray_DIMS( tmp7 )[0];
14801 }
14802 else
14803 {
14804 arg7 = NULL;
14805 arg8 = 0;
14806 }
14807 }
14808 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14809 resultobj = SWIG_Py_Void();
14810 {
14812 }
14813 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14814 {
14815 Py_CLEAR( tmp7 );
14816 }
14817 return resultobj;
14818fail:
14819 {
14821 }
14822 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14823 {
14824 Py_CLEAR( tmp7 );
14825 }
14826 return NULL;
14827}
14828
14829
14830SWIGINTERN PyObject *_wrap_plmeridians(PyObject *self, PyObject *args) {
14831 PyObject *resultobj = 0;
14832 mapform_func arg1 = 0 ;
14833 PLFLT arg2 ;
14834 PLFLT arg3 ;
14835 PLFLT arg4 ;
14836 PLFLT arg5 ;
14837 PLFLT arg6 ;
14838 PLFLT arg7 ;
14839 double val2 ;
14840 int ecode2 = 0 ;
14841 double val3 ;
14842 int ecode3 = 0 ;
14843 double val4 ;
14844 int ecode4 = 0 ;
14845 double val5 ;
14846 int ecode5 = 0 ;
14847 double val6 ;
14848 int ecode6 = 0 ;
14849 double val7 ;
14850 int ecode7 = 0 ;
14851 PyObject *swig_obj[7] ;
14852
14853 (void)self;
14854 if (!SWIG_Python_UnpackTuple(args, "plmeridians", 7, 7, swig_obj)) SWIG_fail;
14855 {
14856 // it must be a callable or none
14857 if ( swig_obj[0] == Py_None )
14858 {
14859 arg1 = NULL;
14860 }
14861 else
14862 {
14863 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14864 {
14865 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14866 return NULL;
14867 }
14868 arg1 = marshal_mapform( swig_obj[0] );
14869 }
14870 }
14871 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14872 if (!SWIG_IsOK(ecode2)) {
14873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14874 }
14875 arg2 = (PLFLT)(val2);
14876 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14877 if (!SWIG_IsOK(ecode3)) {
14878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14879 }
14880 arg3 = (PLFLT)(val3);
14881 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14882 if (!SWIG_IsOK(ecode4)) {
14883 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14884 }
14885 arg4 = (PLFLT)(val4);
14886 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14887 if (!SWIG_IsOK(ecode5)) {
14888 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14889 }
14890 arg5 = (PLFLT)(val5);
14891 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14892 if (!SWIG_IsOK(ecode6)) {
14893 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14894 }
14895 arg6 = (PLFLT)(val6);
14896 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14897 if (!SWIG_IsOK(ecode7)) {
14898 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14899 }
14900 arg7 = (PLFLT)(val7);
14901 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14902 resultobj = SWIG_Py_Void();
14903 {
14905 }
14906 return resultobj;
14907fail:
14908 {
14910 }
14911 return NULL;
14912}
14913
14914
14915SWIGINTERN PyObject *_wrap_plimage(PyObject *self, PyObject *args) {
14916 PyObject *resultobj = 0;
14917 PLFLT **arg1 = 0 ;
14918 PLINT arg2 ;
14919 PLINT arg3 ;
14920 PLFLT arg4 ;
14921 PLFLT arg5 ;
14922 PLFLT arg6 ;
14923 PLFLT arg7 ;
14924 PLFLT arg8 ;
14925 PLFLT arg9 ;
14926 PLFLT arg10 ;
14927 PLFLT arg11 ;
14928 PLFLT arg12 ;
14929 PLFLT arg13 ;
14930 PyArrayObject *tmp1 = NULL ;
14931 double val4 ;
14932 int ecode4 = 0 ;
14933 double val5 ;
14934 int ecode5 = 0 ;
14935 double val6 ;
14936 int ecode6 = 0 ;
14937 double val7 ;
14938 int ecode7 = 0 ;
14939 double val8 ;
14940 int ecode8 = 0 ;
14941 double val9 ;
14942 int ecode9 = 0 ;
14943 double val10 ;
14944 int ecode10 = 0 ;
14945 double val11 ;
14946 int ecode11 = 0 ;
14947 double val12 ;
14948 int ecode12 = 0 ;
14949 double val13 ;
14950 int ecode13 = 0 ;
14951 PyObject *swig_obj[11] ;
14952
14953 (void)self;
14954 if (!SWIG_Python_UnpackTuple(args, "plimage", 11, 11, swig_obj)) SWIG_fail;
14955 {
14956 int i, size;
14957 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14958 if ( tmp1 == NULL )
14959 return NULL;
14960 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14961 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14962 size = arg3;
14963 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14964 for ( i = 0; i < arg2; i++ )
14965 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14966 }
14967 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14968 if (!SWIG_IsOK(ecode4)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14970 }
14971 arg4 = (PLFLT)(val4);
14972 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14973 if (!SWIG_IsOK(ecode5)) {
14974 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14975 }
14976 arg5 = (PLFLT)(val5);
14977 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14978 if (!SWIG_IsOK(ecode6)) {
14979 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14980 }
14981 arg6 = (PLFLT)(val6);
14982 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14983 if (!SWIG_IsOK(ecode7)) {
14984 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14985 }
14986 arg7 = (PLFLT)(val7);
14987 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14988 if (!SWIG_IsOK(ecode8)) {
14989 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14990 }
14991 arg8 = (PLFLT)(val8);
14992 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14993 if (!SWIG_IsOK(ecode9)) {
14994 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14995 }
14996 arg9 = (PLFLT)(val9);
14997 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14998 if (!SWIG_IsOK(ecode10)) {
14999 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
15000 }
15001 arg10 = (PLFLT)(val10);
15002 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
15003 if (!SWIG_IsOK(ecode11)) {
15004 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
15005 }
15006 arg11 = (PLFLT)(val11);
15007 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
15008 if (!SWIG_IsOK(ecode12)) {
15009 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
15010 }
15011 arg12 = (PLFLT)(val12);
15012 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
15013 if (!SWIG_IsOK(ecode13)) {
15014 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
15015 }
15016 arg13 = (PLFLT)(val13);
15017 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15018 resultobj = SWIG_Py_Void();
15019 {
15020 Py_CLEAR( tmp1 );
15021 free( arg1 );
15022 }
15023 return resultobj;
15024fail:
15025 {
15026 Py_CLEAR( tmp1 );
15027 free( arg1 );
15028 }
15029 return NULL;
15030}
15031
15032
15033SWIGINTERN PyObject *_wrap_plimagefr(PyObject *self, PyObject *args) {
15034 PyObject *resultobj = 0;
15035 PLFLT **arg1 = 0 ;
15036 PLINT arg2 ;
15037 PLINT arg3 ;
15038 PLFLT arg4 ;
15039 PLFLT arg5 ;
15040 PLFLT arg6 ;
15041 PLFLT arg7 ;
15042 PLFLT arg8 ;
15043 PLFLT arg9 ;
15044 PLFLT arg10 ;
15045 PLFLT arg11 ;
15046 pltr_func arg12 = 0 ;
15047 PLPointer arg13 = 0 ;
15048 PyArrayObject *tmp1 = NULL ;
15049 double val4 ;
15050 int ecode4 = 0 ;
15051 double val5 ;
15052 int ecode5 = 0 ;
15053 double val6 ;
15054 int ecode6 = 0 ;
15055 double val7 ;
15056 int ecode7 = 0 ;
15057 double val8 ;
15058 int ecode8 = 0 ;
15059 double val9 ;
15060 int ecode9 = 0 ;
15061 double val10 ;
15062 int ecode10 = 0 ;
15063 double val11 ;
15064 int ecode11 = 0 ;
15065 PyObject *swig_obj[11] ;
15066
15067 {
15068 python_pltr = 0;
15069 arg12 = NULL;
15070 }
15071 {
15072 arg13 = NULL;
15073 }
15074 (void)self;
15075 if (!SWIG_Python_UnpackTuple(args, "plimagefr", 9, 11, swig_obj)) SWIG_fail;
15076 {
15077 int i, size;
15078 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15079 if ( tmp1 == NULL )
15080 return NULL;
15081 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15082 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15083 size = arg3;
15084 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15085 for ( i = 0; i < arg2; i++ )
15086 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15087 }
15088 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
15089 if (!SWIG_IsOK(ecode4)) {
15090 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15091 }
15092 arg4 = (PLFLT)(val4);
15093 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
15094 if (!SWIG_IsOK(ecode5)) {
15095 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15096 }
15097 arg5 = (PLFLT)(val5);
15098 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
15099 if (!SWIG_IsOK(ecode6)) {
15100 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15101 }
15102 arg6 = (PLFLT)(val6);
15103 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
15104 if (!SWIG_IsOK(ecode7)) {
15105 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15106 }
15107 arg7 = (PLFLT)(val7);
15108 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
15109 if (!SWIG_IsOK(ecode8)) {
15110 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15111 }
15112 arg8 = (PLFLT)(val8);
15113 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
15114 if (!SWIG_IsOK(ecode9)) {
15115 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15116 }
15117 arg9 = (PLFLT)(val9);
15118 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
15119 if (!SWIG_IsOK(ecode10)) {
15120 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15121 }
15122 arg10 = (PLFLT)(val10);
15123 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
15124 if (!SWIG_IsOK(ecode11)) {
15125 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15126 }
15127 arg11 = (PLFLT)(val11);
15128 if (swig_obj[9]) {
15129 {
15130 // it must be a callable or None
15131 if ( swig_obj[9] == Py_None )
15132 {
15133 arg12 = NULL;
15134 }
15135 else
15136 {
15137 if ( !PyCallable_Check( (PyObject *) swig_obj[9] ) )
15138 {
15139 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
15140 return NULL;
15141 }
15142 arg12 = marshal_pltr( swig_obj[9] );
15143 }
15144 }
15145 }
15146 if (swig_obj[10]) {
15147 {
15148 if ( swig_obj[10] == Py_None )
15149 arg13 = NULL;
15150 else
15151 {
15152 arg13 = marshal_PLPointer( swig_obj[10], 1 );
15153 }
15154 }
15155 }
15156 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15157 resultobj = SWIG_Py_Void();
15158 {
15159 Py_CLEAR( tmp1 );
15160 free( arg1 );
15161 }
15162 {
15163 cleanup_pltr();
15164 }
15165 {
15167 }
15168 return resultobj;
15169fail:
15170 {
15171 Py_CLEAR( tmp1 );
15172 free( arg1 );
15173 }
15174 {
15175 cleanup_pltr();
15176 }
15177 {
15179 }
15180 return NULL;
15181}
15182
15183
15184SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *self, PyObject *args) {
15185 PyObject *resultobj = 0;
15186
15187 (void)self;
15188 if (!SWIG_Python_UnpackTuple(args, "plClearOpts", 0, 0, 0)) SWIG_fail;
15189 plClearOpts();
15190 resultobj = SWIG_Py_Void();
15191 return resultobj;
15192fail:
15193 return NULL;
15194}
15195
15196
15197SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *self, PyObject *args) {
15198 PyObject *resultobj = 0;
15199
15200 (void)self;
15201 if (!SWIG_Python_UnpackTuple(args, "plResetOpts", 0, 0, 0)) SWIG_fail;
15202 plResetOpts();
15203 resultobj = SWIG_Py_Void();
15204 return resultobj;
15205fail:
15206 return NULL;
15207}
15208
15209
15210SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *self, PyObject *args) {
15211 PyObject *resultobj = 0;
15212 char *arg1 = 0 ;
15213 char *arg2 = 0 ;
15214 int res1 ;
15215 char *buf1 = 0 ;
15216 int alloc1 = 0 ;
15217 int res2 ;
15218 char *buf2 = 0 ;
15219 int alloc2 = 0 ;
15220 PyObject *swig_obj[2] ;
15221
15222 (void)self;
15223 if (!SWIG_Python_UnpackTuple(args, "plSetUsage", 2, 2, swig_obj)) SWIG_fail;
15224 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
15225 if (!SWIG_IsOK(res1)) {
15226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
15227 }
15228 arg1 = (char *)(buf1);
15229 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
15230 if (!SWIG_IsOK(res2)) {
15231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
15232 }
15233 arg2 = (char *)(buf2);
15234 plSetUsage((char const *)arg1,(char const *)arg2);
15235 resultobj = SWIG_Py_Void();
15236 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15237 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15238 return resultobj;
15239fail:
15240 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15241 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15242 return NULL;
15243}
15244
15245
15246SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *self, PyObject *args) {
15247 PyObject *resultobj = 0;
15248
15249 (void)self;
15250 if (!SWIG_Python_UnpackTuple(args, "plOptUsage", 0, 0, 0)) SWIG_fail;
15251 plOptUsage();
15252 resultobj = SWIG_Py_Void();
15253 return resultobj;
15254fail:
15255 return NULL;
15256}
15257
15258
15259SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *self, PyObject *args) {
15260 PyObject *resultobj = 0;
15261 PLFLT **arg1 = 0 ;
15262 PLINT arg2 ;
15263 PLINT arg3 ;
15264 PLFLT *arg4 = 0 ;
15265 PLFLT *arg5 = 0 ;
15266 PyArrayObject *tmp1 = NULL ;
15267 PLFLT temp4 ;
15268 int res4 = SWIG_TMPOBJ ;
15269 PLFLT temp5 ;
15270 int res5 = SWIG_TMPOBJ ;
15271 PyObject *swig_obj[1] ;
15272
15273 arg4 = &temp4;
15274 arg5 = &temp5;
15275 (void)self;
15276 if (!args) SWIG_fail;
15277 swig_obj[0] = args;
15278 {
15279 int i, size;
15280 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15281 if ( tmp1 == NULL )
15282 return NULL;
15283 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15284 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15285 size = arg3;
15286 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15287 for ( i = 0; i < arg2; i++ )
15288 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15289 }
15290 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
15291 resultobj = SWIG_Py_Void();
15292 if (SWIG_IsTmpObj(res4)) {
15293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
15294 } else {
15295 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15296 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
15297 }
15298 if (SWIG_IsTmpObj(res5)) {
15299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
15300 } else {
15301 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
15303 }
15304 {
15305 Py_CLEAR( tmp1 );
15306 free( arg1 );
15307 }
15308 return resultobj;
15309fail:
15310 {
15311 Py_CLEAR( tmp1 );
15312 free( arg1 );
15313 }
15314 return NULL;
15315}
15316
15317
15318SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *self, PyObject *args) {
15319 PyObject *resultobj = 0;
15320 PLGraphicsIn *arg1 = 0 ;
15321 void *argp1 = 0 ;
15322 int res1 = 0 ;
15323 PyObject *swig_obj[1] ;
15324 PLINT result;
15325
15326 (void)self;
15327 if (!args) SWIG_fail;
15328 swig_obj[0] = args;
15329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15330 if (!SWIG_IsOK(res1)) {
15331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15332 }
15333 arg1 = (PLGraphicsIn *)(argp1);
15334 result = (PLINT)plGetCursor(arg1);
15335 resultobj = SWIG_From_int((int)(result));
15336 return resultobj;
15337fail:
15338 return NULL;
15339}
15340
15341
15342static PyMethodDef SwigMethods[] = {
15343 { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
15344 { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
15345 { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
15346 { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
15347 { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_O, NULL},
15348 { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
15349 { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_O, NULL},
15350 { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
15351 { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_O, NULL},
15352 { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
15353 { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_O, NULL},
15354 { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
15355 { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_O, NULL},
15356 { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
15357 { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_O, NULL},
15358 { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
15359 { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_O, NULL},
15360 { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
15361 { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_O, NULL},
15362 { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
15363 { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_O, NULL},
15364 { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
15365 { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_O, NULL},
15366 { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
15367 { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_O, NULL},
15368 { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
15369 { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_O, NULL},
15370 { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_NOARGS, NULL},
15371 { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_O, NULL},
15372 { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_O, NULL},
15373 { "PLGraphicsIn_swiginit", PLGraphicsIn_swiginit, METH_VARARGS, NULL},
15374 { "plsxwin", _wrap_plsxwin, METH_O, NULL},
15375 { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, "\n"
15376 "Set format of numerical label for contours\n"
15377 "\n"
15378 "DESCRIPTION:\n"
15379 "\n"
15380 " Set format of numerical label for contours.\n"
15381 "\n"
15382 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15383 "\n"
15384 " This function is used example 9.\n"
15385 "\n"
15386 "\n"
15387 "\n"
15388 "SYNOPSIS:\n"
15389 "\n"
15390 "pl_setcontlabelformat(lexp, sigdig)\n"
15391 "\n"
15392 "ARGUMENTS:\n"
15393 "\n"
15394 " lexp (PLINT, input) : If the contour numerical label is greater\n"
15395 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15396 " format is used. Default value of lexp is 4.\n"
15397 "\n"
15398 " sigdig (PLINT, input) : Number of significant digits. Default\n"
15399 " value is 2.\n"
15400 "\n"
15401 ""},
15402 { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, "\n"
15403 "Set parameters of contour labelling other than format of numerical label\n"
15404 "\n"
15405 "DESCRIPTION:\n"
15406 "\n"
15407 " Set parameters of contour labelling other than those handled by\n"
15408 " pl_setcontlabelformat.\n"
15409 "\n"
15410 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15411 "\n"
15412 " This function is used in example 9.\n"
15413 "\n"
15414 "\n"
15415 "\n"
15416 "SYNOPSIS:\n"
15417 "\n"
15418 "pl_setcontlabelparam(offset, size, spacing, active)\n"
15419 "\n"
15420 "ARGUMENTS:\n"
15421 "\n"
15422 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15423 " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
15424 "\n"
15425 " size (PLFLT, input) : Font height for contour labels (normalized).\n"
15426 " Default value is 0.3.\n"
15427 "\n"
15428 " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
15429 " Default value is 0.1.\n"
15430 "\n"
15431 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15432 " contour labels on. Default is off (0).\n"
15433 "\n"
15434 ""},
15435 { "pladv", _wrap_pladv, METH_O, "\n"
15436 "Advance the (sub-)page\n"
15437 "\n"
15438 "DESCRIPTION:\n"
15439 "\n"
15440 " Advances to the next subpage if sub=0, performing a page advance if\n"
15441 " there are no remaining subpages on the current page. If subpages\n"
15442 " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15443 " PLplot switches to the specified subpage. Note that this allows you\n"
15444 " to overwrite a plot on the specified subpage; if this is not what you\n"
15445 " intended, use pleop followed by plbop to first advance the page. This\n"
15446 " routine is called automatically (with page=0) by plenv, but if plenv\n"
15447 " is not used, pladv must be called after initializing PLplot but before\n"
15448 " defining the viewport.\n"
15449 "\n"
15450 " Redacted form: pladv(page)\n"
15451 "\n"
15452 " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
15453 " 29, and 31.\n"
15454 "\n"
15455 "\n"
15456 "\n"
15457 "SYNOPSIS:\n"
15458 "\n"
15459 "pladv(page)\n"
15460 "\n"
15461 "ARGUMENTS:\n"
15462 "\n"
15463 " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15464 " in the top left corner and increasing along the rows) to which to\n"
15465 " advance. Set to zero to advance to the next subpage (or to the\n"
15466 " next page if subpages are not being used).\n"
15467 "\n"
15468 ""},
15469 { "plarc", _wrap_plarc, METH_VARARGS, "\n"
15470 "Draw a circular or elliptical arc\n"
15471 "\n"
15472 "DESCRIPTION:\n"
15473 "\n"
15474 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15475 " semiminor axis b, starting at angle1 and ending at angle2.\n"
15476 "\n"
15477 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15478 " fill)\n"
15479 "\n"
15480 "\n"
15481 " This function is used in examples 3 and 27.\n"
15482 "\n"
15483 "\n"
15484 "\n"
15485 "SYNOPSIS:\n"
15486 "\n"
15487 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15488 "\n"
15489 "ARGUMENTS:\n"
15490 "\n"
15491 " x (PLFLT, input) : X coordinate of arc center.\n"
15492 "\n"
15493 " y (PLFLT, input) : Y coordinate of arc center.\n"
15494 "\n"
15495 " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15496 "\n"
15497 " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15498 "\n"
15499 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15500 " semimajor axis.\n"
15501 "\n"
15502 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15503 " semimajor axis.\n"
15504 "\n"
15505 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15506 " X-axis.\n"
15507 "\n"
15508 " fill (PLBOOL, input) : Draw a filled arc.\n"
15509 "\n"
15510 ""},
15511 { "plaxes", _wrap_plaxes, METH_VARARGS, "\n"
15512 "Draw a box with axes, etc. with arbitrary origin\n"
15513 "\n"
15514 "DESCRIPTION:\n"
15515 "\n"
15516 " Draws a box around the currently defined viewport with arbitrary\n"
15517 " world-coordinate origin specified by x0 and y0 and labels it with\n"
15518 " world coordinate values appropriate to the window. Thus plaxes should\n"
15519 " only be called after defining both viewport and window. The ascii\n"
15520 " character strings xopt and yopt specify how the box should be drawn as\n"
15521 " described below. If ticks and/or subticks are to be drawn for a\n"
15522 " particular axis, the tick intervals and number of subintervals may be\n"
15523 " specified explicitly, or they may be defaulted by setting the\n"
15524 " appropriate arguments to zero.\n"
15525 "\n"
15526 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15527 " ytick, nysub)\n"
15528 "\n"
15529 "\n"
15530 " This function is not used in any examples.\n"
15531 "\n"
15532 "\n"
15533 "\n"
15534 "SYNOPSIS:\n"
15535 "\n"
15536 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15537 "\n"
15538 "ARGUMENTS:\n"
15539 "\n"
15540 " x0 (PLFLT, input) : World X coordinate of origin.\n"
15541 "\n"
15542 " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15543 "\n"
15544 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15545 " options for the x axis. The string can include any combination of\n"
15546 " the following letters (upper or lower case) in any order: a: Draws\n"
15547 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15548 " (x=0).\n"
15549 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15550 " c: Draws top (X) or right (Y) edge of frame.\n"
15551 " d: Plot labels as date / time. Values are assumed to be\n"
15552 " seconds since the epoch (as used by gmtime).\n"
15553 " f: Always use fixed point numeric labels.\n"
15554 " g: Draws a grid at the major tick interval.\n"
15555 " h: Draws a grid at the minor tick interval.\n"
15556 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15557 " inwards.\n"
15558 " l: Labels axis logarithmically. This only affects the labels,\n"
15559 " not the data, and so it is necessary to compute the logarithms\n"
15560 " of data points before passing them to any of the drawing\n"
15561 " routines.\n"
15562 " m: Writes numeric labels at major tick intervals in the\n"
15563 " unconventional location (above box for X, right of box for Y).\n"
15564 " n: Writes numeric labels at major tick intervals in the\n"
15565 " conventional location (below box for X, left of box for Y).\n"
15566 " o: Use custom labelling function to generate axis label text.\n"
15567 " The custom labelling function can be defined with the\n"
15568 " plslabelfunc command.\n"
15569 " s: Enables subticks between major ticks, only valid if t is\n"
15570 " also specified.\n"
15571 " t: Draws major ticks.\n"
15572 " u: Exactly like \"b\" except don't draw edge line.\n"
15573 " w: Exactly like \"c\" except don't draw edge line.\n"
15574 " x: Exactly like \"t\" (including the side effect of the\n"
15575 " numerical labels for the major ticks) except exclude drawing\n"
15576 " the major and minor tick marks.\n"
15577 "\n"
15578 "\n"
15579 " xtick (PLFLT, input) : World coordinate interval between major\n"
15580 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15581 " generates a suitable tick interval.\n"
15582 "\n"
15583 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15584 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15585 " generates a suitable minor tick interval.\n"
15586 "\n"
15587 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15588 " options for the y axis. The string can include any combination of\n"
15589 " the letters defined above for xopt, and in addition may contain:\n"
15590 " v: Write numeric labels for the y axis parallel to the base of the\n"
15591 " graph, rather than parallel to the axis.\n"
15592 "\n"
15593 "\n"
15594 " ytick (PLFLT, input) : World coordinate interval between major\n"
15595 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15596 " generates a suitable tick interval.\n"
15597 "\n"
15598 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15599 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15600 " generates a suitable minor tick interval.\n"
15601 "\n"
15602 ""},
15603 { "plbin", _wrap_plbin, METH_VARARGS, "\n"
15604 "Plot a histogram from binned data\n"
15605 "\n"
15606 "DESCRIPTION:\n"
15607 "\n"
15608 " Plots a histogram consisting of nbin bins. The value associated with\n"
15609 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15610 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15611 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15612 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15613 " placed midway between the values in the x vector. Also see plhist for\n"
15614 " drawing histograms from unbinned data.\n"
15615 "\n"
15616 " Redacted form: General: plbin(x, y, opt)\n"
15617 " Python: plbin(nbin, x, y, opt)\n"
15618 "\n"
15619 "\n"
15620 " This function is not used in any examples.\n"
15621 "\n"
15622 "\n"
15623 "\n"
15624 "SYNOPSIS:\n"
15625 "\n"
15626 "plbin(nbin, x, y, opt)\n"
15627 "\n"
15628 "ARGUMENTS:\n"
15629 "\n"
15630 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15631 " and y vectors.)\n"
15632 "\n"
15633 " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15634 " with bins. These must form a strictly increasing sequence.\n"
15635 "\n"
15636 " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15637 " proportional to the number of points in each bin. This is a PLFLT\n"
15638 " (instead of PLINT) vector so as to allow histograms of\n"
15639 " probabilities, etc.\n"
15640 "\n"
15641 " opt (PLINT, input) : Is a combination of several flags:\n"
15642 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15643 " outer bins are expanded to fill up the entire x-axis and bins of\n"
15644 " zero height are simply drawn.\n"
15645 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15646 " between the x values. If the values in x are equally spaced,\n"
15647 " the values are the center values of the bins.\n"
15648 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15649 " size as the ones inside.\n"
15650 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15651 " (there is a gap for such bins).\n"
15652 "\n"
15653 ""},
15654 { "plbtime", _wrap_plbtime, METH_O, "\n"
15655 "Calculate broken-down time from continuous time for the current stream\n"
15656 "\n"
15657 "DESCRIPTION:\n"
15658 "\n"
15659 " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15660 " continuous time, ctime for the current stream. This function is the\n"
15661 " inverse of plctime.\n"
15662 "\n"
15663 " The PLplot definition of broken-down time is a calendar time that\n"
15664 " completely ignores all time zone offsets, i.e., it is the user's\n"
15665 " responsibility to apply those offsets (if so desired) before using the\n"
15666 " PLplot time API. By default broken-down time is defined using the\n"
15667 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15668 " continuous time is defined as the number of seconds since the Unix\n"
15669 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15670 " broken-down and continuous time are possible, see plconfigtime.\n"
15671 "\n"
15672 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15673 " ctime)\n"
15674 "\n"
15675 "\n"
15676 " This function is used in example 29.\n"
15677 "\n"
15678 "\n"
15679 "\n"
15680 "SYNOPSIS:\n"
15681 "\n"
15682 "plbtime(year, month, day, hour, min, sec, ctime)\n"
15683 "\n"
15684 "ARGUMENTS:\n"
15685 "\n"
15686 " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15687 " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15688 " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15689 " BCE, etc.)\n"
15690 "\n"
15691 " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15692 " the year in the range from 0 (January) to 11 (December).\n"
15693 "\n"
15694 " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15695 " month in the range from 1 to 31.\n"
15696 "\n"
15697 " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15698 " day in the range from 0 to 23.\n"
15699 "\n"
15700 " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15701 " hour in the range from 0 to 59\n"
15702 "\n"
15703 " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15704 " minute in range from 0. to 60.\n"
15705 "\n"
15706 " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
15707 " time is calculated.\n"
15708 "\n"
15709 ""},
15710 { "plbop", _wrap_plbop, METH_NOARGS, "\n"
15711 "Begin a new page\n"
15712 "\n"
15713 "DESCRIPTION:\n"
15714 "\n"
15715 " Begins a new page. For a file driver, the output file is opened if\n"
15716 " necessary. Advancing the page via pleop and plbop is useful when a\n"
15717 " page break is desired at a particular point when plotting to subpages.\n"
15718 " Another use for pleop and plbop is when plotting pages to different\n"
15719 " files, since you can manually set the file name by calling plsfnam\n"
15720 " after the call to pleop. (In fact some drivers may only support a\n"
15721 " single page per file, making this a necessity.) One way to handle\n"
15722 " this case automatically is to page advance via pladv, but enable\n"
15723 " familying (see plsfam) with a small limit on the file size so that a\n"
15724 " new family member file will be created on each page break.\n"
15725 "\n"
15726 " Redacted form: plbop()\n"
15727 "\n"
15728 " This function is used in examples 2 and 20.\n"
15729 "\n"
15730 "\n"
15731 "\n"
15732 "SYNOPSIS:\n"
15733 "\n"
15734 "plbop()\n"
15735 "\n"
15736 ""},
15737 { "plbox", _wrap_plbox, METH_VARARGS, "\n"
15738 "Draw a box with axes, etc\n"
15739 "\n"
15740 "DESCRIPTION:\n"
15741 "\n"
15742 " Draws a box around the currently defined viewport, and labels it with\n"
15743 " world coordinate values appropriate to the window. Thus plbox should\n"
15744 " only be called after defining both viewport and window. The ascii\n"
15745 " character strings xopt and yopt specify how the box should be drawn as\n"
15746 " described below. If ticks and/or subticks are to be drawn for a\n"
15747 " particular axis, the tick intervals and number of subintervals may be\n"
15748 " specified explicitly, or they may be defaulted by setting the\n"
15749 " appropriate arguments to zero.\n"
15750 "\n"
15751 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15752 "\n"
15753 "\n"
15754 " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15755 " and 29.\n"
15756 "\n"
15757 "\n"
15758 "\n"
15759 "SYNOPSIS:\n"
15760 "\n"
15761 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15762 "\n"
15763 "ARGUMENTS:\n"
15764 "\n"
15765 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15766 " options for the x axis. The string can include any combination of\n"
15767 " the following letters (upper or lower case) in any order: a: Draws\n"
15768 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15769 " (x=0).\n"
15770 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15771 " c: Draws top (X) or right (Y) edge of frame.\n"
15772 " d: Plot labels as date / time. Values are assumed to be\n"
15773 " seconds since the epoch (as used by gmtime).\n"
15774 " f: Always use fixed point numeric labels.\n"
15775 " g: Draws a grid at the major tick interval.\n"
15776 " h: Draws a grid at the minor tick interval.\n"
15777 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15778 " inwards.\n"
15779 " l: Labels axis logarithmically. This only affects the labels,\n"
15780 " not the data, and so it is necessary to compute the logarithms\n"
15781 " of data points before passing them to any of the drawing\n"
15782 " routines.\n"
15783 " m: Writes numeric labels at major tick intervals in the\n"
15784 " unconventional location (above box for X, right of box for Y).\n"
15785 " n: Writes numeric labels at major tick intervals in the\n"
15786 " conventional location (below box for X, left of box for Y).\n"
15787 " o: Use custom labelling function to generate axis label text.\n"
15788 " The custom labelling function can be defined with the\n"
15789 " plslabelfunc command.\n"
15790 " s: Enables subticks between major ticks, only valid if t is\n"
15791 " also specified.\n"
15792 " t: Draws major ticks.\n"
15793 " u: Exactly like \"b\" except don't draw edge line.\n"
15794 " w: Exactly like \"c\" except don't draw edge line.\n"
15795 " x: Exactly like \"t\" (including the side effect of the\n"
15796 " numerical labels for the major ticks) except exclude drawing\n"
15797 " the major and minor tick marks.\n"
15798 "\n"
15799 "\n"
15800 " xtick (PLFLT, input) : World coordinate interval between major\n"
15801 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15802 " generates a suitable tick interval.\n"
15803 "\n"
15804 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15805 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15806 " generates a suitable minor tick interval.\n"
15807 "\n"
15808 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15809 " options for the y axis. The string can include any combination of\n"
15810 " the letters defined above for xopt, and in addition may contain:\n"
15811 " v: Write numeric labels for the y axis parallel to the base of the\n"
15812 " graph, rather than parallel to the axis.\n"
15813 "\n"
15814 "\n"
15815 " ytick (PLFLT, input) : World coordinate interval between major\n"
15816 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15817 " generates a suitable tick interval.\n"
15818 "\n"
15819 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15820 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15821 " generates a suitable minor tick interval.\n"
15822 "\n"
15823 ""},
15824 { "plbox3", _wrap_plbox3, METH_VARARGS, "\n"
15825 "Draw a box with axes, etc, in 3-d\n"
15826 "\n"
15827 "DESCRIPTION:\n"
15828 "\n"
15829 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15830 " plot. For a more complete description of three-dimensional plotting\n"
15831 " see the PLplot documentation.\n"
15832 "\n"
15833 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15834 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15835 "\n"
15836 "\n"
15837 " This function is used in examples 8, 11, 18, and 21.\n"
15838 "\n"
15839 "\n"
15840 "\n"
15841 "SYNOPSIS:\n"
15842 "\n"
15843 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15844 "\n"
15845 "ARGUMENTS:\n"
15846 "\n"
15847 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15848 " options for the x axis. The string can include any combination of\n"
15849 " the following letters (upper or lower case) in any order: b: Draws\n"
15850 " axis at base, at height z=\n"
15851 " zmin where zmin is defined by call to plw3d. This character must be\n"
15852 " specified in order to use any of the other options.\n"
15853 " d: Plot labels as date / time. Values are assumed to be\n"
15854 " seconds since the epoch (as used by gmtime).\n"
15855 " f: Always use fixed point numeric labels.\n"
15856 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15857 " than upwards.\n"
15858 " l: Labels axis logarithmically. This only affects the labels,\n"
15859 " not the data, and so it is necessary to compute the logarithms\n"
15860 " of data points before passing them to any of the drawing\n"
15861 " routines.\n"
15862 " n: Writes numeric labels at major tick intervals.\n"
15863 " o: Use custom labelling function to generate axis label text.\n"
15864 " The custom labelling function can be defined with the\n"
15865 " plslabelfunc command.\n"
15866 " s: Enables subticks between major ticks, only valid if t is\n"
15867 " also specified.\n"
15868 " t: Draws major ticks.\n"
15869 " u: If this is specified, the text label for the axis is\n"
15870 " written under the axis.\n"
15871 "\n"
15872 "\n"
15873 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15874 " the text label for the x axis. It is only drawn if u is in the\n"
15875 " xopt string.\n"
15876 "\n"
15877 " xtick (PLFLT, input) : World coordinate interval between major\n"
15878 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15879 " generates a suitable tick interval.\n"
15880 "\n"
15881 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15882 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15883 " generates a suitable minor tick interval.\n"
15884 "\n"
15885 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15886 " options for the y axis. The string is interpreted in the same way\n"
15887 " as xopt.\n"
15888 "\n"
15889 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15890 " the text label for the y axis. It is only drawn if u is in the\n"
15891 " yopt string.\n"
15892 "\n"
15893 " ytick (PLFLT, input) : World coordinate interval between major\n"
15894 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15895 " generates a suitable tick interval.\n"
15896 "\n"
15897 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15898 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15899 " generates a suitable minor tick interval.\n"
15900 "\n"
15901 " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15902 " options for the z axis. The string can include any combination of\n"
15903 " the following letters (upper or lower case) in any order: b: Draws\n"
15904 " z axis to the left of the surface plot.\n"
15905 " c: Draws z axis to the right of the surface plot.\n"
15906 " d: Draws grid lines parallel to the x-y plane behind the\n"
15907 " figure. These lines are not drawn until after plot3d or\n"
15908 " plmesh are called because of the need for hidden line removal.\n"
15909 " e: Plot labels as date / time. Values are assumed to be\n"
15910 " seconds since the epoch (as used by gmtime). Note this\n"
15911 " suboption is interpreted the same as the d suboption for xopt\n"
15912 " and yopt, but it has to be identified as e for zopt since d\n"
15913 " has already been used for the different purpose above.\n"
15914 " f: Always use fixed point numeric labels.\n"
15915 " i: Inverts tick marks, so they are drawn away from the center.\n"
15916 " l: Labels axis logarithmically. This only affects the labels,\n"
15917 " not the data, and so it is necessary to compute the logarithms\n"
15918 " of data points before passing them to any of the drawing\n"
15919 " routines.\n"
15920 " m: Writes numeric labels at major tick intervals on the\n"
15921 " right-hand z axis.\n"
15922 " n: Writes numeric labels at major tick intervals on the\n"
15923 " left-hand z axis.\n"
15924 " o: Use custom labelling function to generate axis label text.\n"
15925 " The custom labelling function can be defined with the\n"
15926 " plslabelfunc command.\n"
15927 " s: Enables subticks between major ticks, only valid if t is\n"
15928 " also specified.\n"
15929 " t: Draws major ticks.\n"
15930 " u: If this is specified, the text label is written beside the\n"
15931 " left-hand axis.\n"
15932 " v: If this is specified, the text label is written beside the\n"
15933 " right-hand axis.\n"
15934 "\n"
15935 "\n"
15936 " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15937 " the text label for the z axis. It is only drawn if u or v are in\n"
15938 " the zopt string.\n"
15939 "\n"
15940 " ztick (PLFLT, input) : World coordinate interval between major\n"
15941 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15942 " generates a suitable tick interval.\n"
15943 "\n"
15944 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15945 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15946 " generates a suitable minor tick interval.\n"
15947 "\n"
15948 ""},
15949 { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, "\n"
15950 "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15951 "\n"
15952 "DESCRIPTION:\n"
15953 "\n"
15954 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15955 " from relative device coordinates, rx and ry.\n"
15956 "\n"
15957 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15958 "\n"
15959 "\n"
15960 " This function is used in example 31.\n"
15961 "\n"
15962 "\n"
15963 "\n"
15964 "SYNOPSIS:\n"
15965 "\n"
15966 "plcalc_world(rx, ry, wx, wy, window)\n"
15967 "\n"
15968 "ARGUMENTS:\n"
15969 "\n"
15970 " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15971 " the x coordinate.\n"
15972 "\n"
15973 " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15974 " the y coordinate.\n"
15975 "\n"
15976 " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15977 " coordinate corresponding to the relative device coordinates rx and\n"
15978 " ry.\n"
15979 "\n"
15980 " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15981 " coordinate corresponding to the relative device coordinates rx and\n"
15982 " ry.\n"
15983 "\n"
15984 " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15985 " defined window index that corresponds to the input relative device\n"
15986 " coordinates (and the returned world coordinates). To give some\n"
15987 " background on the window index, for each page the initial window\n"
15988 " index is set to zero, and each time plwind is called within the\n"
15989 " page, world and device coordinates are stored for the window and\n"
15990 " the window index is incremented. Thus, for a simple page layout\n"
15991 " with non-overlapping viewports and one window per viewport, window\n"
15992 " corresponds to the viewport index (in the order which the\n"
15993 " viewport/windows were created) of the only viewport/window\n"
15994 " corresponding to rx and ry. However, for more complicated layouts\n"
15995 " with potentially overlapping viewports and possibly more than one\n"
15996 " window (set of world coordinates) per viewport, window and the\n"
15997 " corresponding output world coordinates corresponds to the last\n"
15998 " window created that fulfills the criterion that the relative\n"
15999 " device coordinates are inside it. Finally, in all cases where the\n"
16000 " input relative device coordinates are not inside any\n"
16001 " viewport/window, then the returned value of the last defined\n"
16002 " window index is set to -1.\n"
16003 "\n"
16004 ""},
16005 { "plclear", _wrap_plclear, METH_NOARGS, "\n"
16006 "Clear current (sub)page\n"
16007 "\n"
16008 "DESCRIPTION:\n"
16009 "\n"
16010 " Clears the current page, effectively erasing everything that have been\n"
16011 " drawn. This command only works with interactive drivers; if the\n"
16012 " driver does not support this, the page is filled with the background\n"
16013 " color in use. If the current page is divided into subpages, only the\n"
16014 " current subpage is erased. The nth subpage can be selected with\n"
16015 " pladv(n).\n"
16016 "\n"
16017 " Redacted form: General: plclear()\n"
16018 "\n"
16019 "\n"
16020 " This function is not used in any examples.\n"
16021 "\n"
16022 "\n"
16023 "\n"
16024 "SYNOPSIS:\n"
16025 "\n"
16026 "plclear()\n"
16027 "\n"
16028 ""},
16029 { "plcol0", _wrap_plcol0, METH_O, "\n"
16030 "Set color, cmap0\n"
16031 "\n"
16032 "DESCRIPTION:\n"
16033 "\n"
16034 " Sets the color index for cmap0 (see the PLplot documentation).\n"
16035 "\n"
16036 " Redacted form: plcol0(icol0)\n"
16037 "\n"
16038 " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
16039 "\n"
16040 "\n"
16041 "\n"
16042 "SYNOPSIS:\n"
16043 "\n"
16044 "plcol0(icol0)\n"
16045 "\n"
16046 "ARGUMENTS:\n"
16047 "\n"
16048 " icol0 (PLINT, input) : Integer representing the color. The\n"
16049 " defaults at present are (these may change):\n"
16050 " 0 black (default background)\n"
16051 " 1 red (default foreground)\n"
16052 " 2 yellow\n"
16053 " 3 green\n"
16054 " 4 aquamarine\n"
16055 " 5 pink\n"
16056 " 6 wheat\n"
16057 " 7 grey\n"
16058 " 8 brown\n"
16059 " 9 blue\n"
16060 " 10 BlueViolet\n"
16061 " 11 cyan\n"
16062 " 12 turquoise\n"
16063 " 13 magenta\n"
16064 " 14 salmon\n"
16065 " 15 white\n"
16066 "\n"
16067 " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
16068 " change an individual color in the cmap0 color palette.\n"
16069 "\n"
16070 ""},
16071 { "plcol1", _wrap_plcol1, METH_O, "\n"
16072 "Set color, cmap1\n"
16073 "\n"
16074 "DESCRIPTION:\n"
16075 "\n"
16076 " Sets the color for cmap1 (see the PLplot documentation).\n"
16077 "\n"
16078 " Redacted form: plcol1(col1)\n"
16079 "\n"
16080 " This function is used in examples 12 and 21.\n"
16081 "\n"
16082 "\n"
16083 "\n"
16084 "SYNOPSIS:\n"
16085 "\n"
16086 "plcol1(col1)\n"
16087 "\n"
16088 "ARGUMENTS:\n"
16089 "\n"
16090 " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
16091 " is mapped to color using the continuous cmap1 palette which by\n"
16092 " default ranges from blue to the background color to red. The\n"
16093 " cmap1 palette can also be straightforwardly changed by the user\n"
16094 " with plscmap1 or plscmap1l.\n"
16095 "\n"
16096 ""},
16097 { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, "\n"
16098 "Configure the transformation between continuous and broken-down time for the current stream\n"
16099 "\n"
16100 "DESCRIPTION:\n"
16101 "\n"
16102 " Configure the transformation between continuous and broken-down time\n"
16103 " for the current stream. This transformation is used by both plbtime\n"
16104 " and plctime.\n"
16105 "\n"
16106 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
16107 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16108 "\n"
16109 "\n"
16110 " This function is used in example 29.\n"
16111 "\n"
16112 "\n"
16113 "\n"
16114 "SYNOPSIS:\n"
16115 "\n"
16116 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16117 "\n"
16118 "ARGUMENTS:\n"
16119 "\n"
16120 " scale (PLFLT, input) : The number of days per continuous time unit.\n"
16121 " As a special case, if\n"
16122 " scale is 0., then all other arguments are ignored, and the result (the\n"
16123 " default used by PLplot) is the equivalent of a call to\n"
16124 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
16125 " That is, for this special case broken-down time is calculated with\n"
16126 " the proleptic Gregorian calendar with no leap seconds inserted,\n"
16127 " and the continuous time is defined as the number of seconds since\n"
16128 " the Unix epoch of 1970-01-01T00:00:00Z.\n"
16129 "\n"
16130 " offset1 (PLFLT, input) : If\n"
16131 " ifbtime_offset is true, the parameters\n"
16132 " offset1 and\n"
16133 " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
16134 " (with units in days) specify the epoch of the continuous time\n"
16135 " relative to the MJD epoch corresponding to the Gregorian calendar\n"
16136 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
16137 " are used to specify the origin to allow users (by specifying\n"
16138 " offset1 as an integer that can be exactly represented by a\n"
16139 " floating-point variable and specifying\n"
16140 " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
16141 " the numerical errors of the continuous time representation.\n"
16142 "\n"
16143 " offset2 (PLFLT, input) : See documentation of\n"
16144 " offset1.\n"
16145 "\n"
16146 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
16147 " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
16148 " calendar is used for broken-down time rather than the proleptic\n"
16149 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
16150 " have been historically used to define UTC are inserted into the\n"
16151 " broken-down time. Other possibilities for additional control bits\n"
16152 " for ccontrol exist such as making the historical time corrections\n"
16153 " in the broken-down time corresponding to ET (ephemeris time) or\n"
16154 " making the (slightly non-constant) corrections from international\n"
16155 " atomic time (TAI) to what astronomers define as terrestrial time\n"
16156 " (TT). But those additional possibilities have not been\n"
16157 " implemented yet in the qsastime library (one of the PLplot utility\n"
16158 " libraries).\n"
16159 "\n"
16160 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
16161 " epoch of the continuous time scale is specified by the user. If\n"
16162 " ifbtime_offset is false, then\n"
16163 " offset1 and\n"
16164 " offset2 are used to specify the epoch, and the following broken-down\n"
16165 " time parameters are completely ignored. If\n"
16166 " ifbtime_offset is true, then\n"
16167 " offset1 and\n"
16168 " offset2 are completely ignored, and the following broken-down time\n"
16169 " parameters are used to specify the epoch.\n"
16170 "\n"
16171 " year (PLINT, input) : Year of epoch.\n"
16172 "\n"
16173 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
16174 " 11 (December).\n"
16175 "\n"
16176 " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
16177 "\n"
16178 " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
16179 "\n"
16180 " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
16181 "\n"
16182 " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
16183 "\n"
16184 ""},
16185 { "plcont", _wrap_plcont, METH_VARARGS, "\n"
16186 "Contour plot\n"
16187 "\n"
16188 "DESCRIPTION:\n"
16189 "\n"
16190 " Draws a contour plot of the data in f[\n"
16191 " nx][\n"
16192 " ny], using the nlevel contour levels specified by clevel. Only the\n"
16193 " region of the matrix from kx to lx and from ky to ly is plotted out\n"
16194 " where all these index ranges are interpreted as one-based for\n"
16195 " historical reasons. A transformation routine pointed to by pltr with\n"
16196 " a generic pointer pltr_data for additional data required by the\n"
16197 " transformation routine is used to map indices within the matrix to the\n"
16198 " world coordinates.\n"
16199 "\n"
16200 " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16201 " where (see above discussion) the pltr, pltr_data callback arguments\n"
16202 " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
16203 " vectors; or xg and yg matrices.\n"
16204 "\n"
16205 " This function is used in examples 9, 14, 16, and 22.\n"
16206 "\n"
16207 "\n"
16208 "\n"
16209 "SYNOPSIS:\n"
16210 "\n"
16211 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16212 "\n"
16213 "ARGUMENTS:\n"
16214 "\n"
16215 " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
16216 "\n"
16217 " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
16218 "\n"
16219 " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
16220 " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
16221 " zero-based for historical backwards-compatibility reasons.\n"
16222 "\n"
16223 " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
16224 " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
16225 " zero-based for historical backwards-compatibility reasons.\n"
16226 "\n"
16227 " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
16228 " which to draw contours.\n"
16229 "\n"
16230 " nlevel (PLINT, input) : Number of contour levels to draw.\n"
16231 "\n"
16232 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
16233 " defines the transformation between the zero-based indices of the\n"
16234 " matrix f and the world coordinates.For the C case, transformation\n"
16235 " functions are provided in the PLplot library: pltr0 for the\n"
16236 " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
16237 " respectively defined by vectors and matrices. In addition, C\n"
16238 " callback routines for the transformation can be supplied by the\n"
16239 " user such as the mypltr function in examples/c/x09c.c which\n"
16240 " provides a general linear transformation between index coordinates\n"
16241 " and world coordinates.For languages other than C you should\n"
16242 " consult the PLplot documentation for the details concerning how\n"
16243 " PLTRANSFORM_callback arguments are interfaced. However, in\n"
16244 " general, a particular pattern of callback-associated arguments\n"
16245 " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
16246 " yg matrices are respectively interfaced to a linear-transformation\n"
16247 " routine similar to the above mypltr function; pltr1; and pltr2.\n"
16248 " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
16249 " the PLplot documentation) support native language callbacks for\n"
16250 " handling index to world-coordinate transformations. Examples of\n"
16251 " these various approaches are given in examples/<language>x09*,\n"
16252 " examples/<language>x16*, examples/<language>x20*,\n"
16253 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
16254 " supported languages.\n"
16255 "\n"
16256 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
16257 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
16258 " that is externally supplied.\n"
16259 "\n"
16260 ""},
16261 { "plctime", _wrap_plctime, METH_VARARGS, "\n"
16262 "Calculate continuous time from broken-down time for the current stream\n"
16263 "\n"
16264 "DESCRIPTION:\n"
16265 "\n"
16266 " Calculate continuous time, ctime, from broken-down time for the\n"
16267 " current stream. The broken-down\n"
16268 " time is specified by the following parameters: year, month, day, hour,\n"
16269 " min, and sec. This function is the inverse of plbtime.\n"
16270 "\n"
16271 " The PLplot definition of broken-down time is a calendar time that\n"
16272 " completely ignores all time zone offsets, i.e., it is the user's\n"
16273 " responsibility to apply those offsets (if so desired) before using the\n"
16274 " PLplot time API. By default broken-down time is defined using the\n"
16275 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16276 " continuous time is defined as the number of seconds since the Unix\n"
16277 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16278 " broken-down and continuous time are possible, see plconfigtime which\n"
16279 " specifies that transformation for the current stream.\n"
16280 "\n"
16281 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16282 " ctime)\n"
16283 "\n"
16284 "\n"
16285 " This function is used in example 29.\n"
16286 "\n"
16287 "\n"
16288 "\n"
16289 "SYNOPSIS:\n"
16290 "\n"
16291 "plctime(year, month, day, hour, min, sec, ctime)\n"
16292 "\n"
16293 "ARGUMENTS:\n"
16294 "\n"
16295 " year (PLINT, input) : Input year.\n"
16296 "\n"
16297 " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16298 " (December).\n"
16299 "\n"
16300 " day (PLINT, input) : Input day in range from 1 to 31.\n"
16301 "\n"
16302 " hour (PLINT, input) : Input hour in range from 0 to 23\n"
16303 "\n"
16304 " min (PLINT, input) : Input minute in range from 0 to 59.\n"
16305 "\n"
16306 " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
16307 "\n"
16308 " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
16309 " time calculated from the broken-down time specified by the\n"
16310 " previous parameters.\n"
16311 "\n"
16312 ""},
16313 { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, "\n"
16314 "Copy state parameters from the reference stream to the current stream\n"
16315 "\n"
16316 "DESCRIPTION:\n"
16317 "\n"
16318 " Copies state parameters from the reference stream to the current\n"
16319 " stream. Tell driver interface to map device coordinates unless flags\n"
16320 " == 1.\n"
16321 "\n"
16322 " This function is used for making save files of selected plots (e.g.\n"
16323 " from the TK driver). After initializing, you can get a copy of the\n"
16324 " current plot to the specified device by switching to this stream and\n"
16325 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16326 " appropriate. The plot buffer must have previously been enabled (done\n"
16327 " automatically by some display drivers, such as X).\n"
16328 "\n"
16329 " Redacted form: plcpstrm(iplsr, flags)\n"
16330 "\n"
16331 " This function is used in example 1,20.\n"
16332 "\n"
16333 "\n"
16334 "\n"
16335 "SYNOPSIS:\n"
16336 "\n"
16337 "plcpstrm(iplsr, flags)\n"
16338 "\n"
16339 "ARGUMENTS:\n"
16340 "\n"
16341 " iplsr (PLINT, input) : Number of reference stream.\n"
16342 "\n"
16343 " flags (PLBOOL, input) : If flags is set to true the device\n"
16344 " coordinates are not copied from the reference to current stream.\n"
16345 "\n"
16346 ""},
16347 { "plend", _wrap_plend, METH_NOARGS, "\n"
16348 "End plotting session\n"
16349 "\n"
16350 "DESCRIPTION:\n"
16351 "\n"
16352 " Ends a plotting session, tidies up all the output files, switches\n"
16353 " interactive devices back into text mode and frees up any memory that\n"
16354 " was allocated. Must be called before end of program.\n"
16355 "\n"
16356 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16357 " wait state after a call to plend or other functions which trigger the\n"
16358 " end of a plot page. To avoid this, use the plspause function.\n"
16359 "\n"
16360 " Redacted form: plend()\n"
16361 "\n"
16362 " This function is used in all of the examples.\n"
16363 "\n"
16364 "\n"
16365 "\n"
16366 "SYNOPSIS:\n"
16367 "\n"
16368 "plend()\n"
16369 "\n"
16370 ""},
16371 { "plend1", _wrap_plend1, METH_NOARGS, "\n"
16372 "End plotting session for current stream\n"
16373 "\n"
16374 "DESCRIPTION:\n"
16375 "\n"
16376 " Ends a plotting session for the current output stream only. See\n"
16377 " plsstrm for more info.\n"
16378 "\n"
16379 " Redacted form: plend1()\n"
16380 "\n"
16381 " This function is used in examples 1 and 20.\n"
16382 "\n"
16383 "\n"
16384 "\n"
16385 "SYNOPSIS:\n"
16386 "\n"
16387 "plend1()\n"
16388 "\n"
16389 ""},
16390 { "plenv", _wrap_plenv, METH_VARARGS, "\n"
16391 "Set up standard window and draw box\n"
16392 "\n"
16393 "DESCRIPTION:\n"
16394 "\n"
16395 " Sets up plotter environment for simple graphs by calling pladv and\n"
16396 " setting up viewport and window to sensible default values. plenv\n"
16397 " leaves a standard margin (left-hand margin of eight character heights,\n"
16398 " and a margin around the other three sides of five character heights)\n"
16399 " around most graphs for axis labels and a title. When these defaults\n"
16400 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16401 " plvasp for setting up the viewport, plwind for defining the window,\n"
16402 " and plbox for drawing the box.\n"
16403 "\n"
16404 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16405 "\n"
16406 " This function is used in example 1,3,9,13,14,19-22,29.\n"
16407 "\n"
16408 "\n"
16409 "\n"
16410 "SYNOPSIS:\n"
16411 "\n"
16412 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16413 "\n"
16414 "ARGUMENTS:\n"
16415 "\n"
16416 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16417 " world coordinates).\n"
16418 "\n"
16419 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16420 " world coordinates).\n"
16421 "\n"
16422 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16423 " coordinates).\n"
16424 "\n"
16425 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16426 " coordinates).\n"
16427 "\n"
16428 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16429 " scales will not be set, the user must set up the scale before\n"
16430 " calling plenv using plsvpa, plvasp or other.\n"
16431 " 0: the x and y axes are scaled independently to use as much of\n"
16432 " the screen as possible.\n"
16433 " 1: the scales of the x and y axes are made equal.\n"
16434 " 2: the axis of the x and y axes are made equal, and the plot\n"
16435 " box will be square.\n"
16436 "\n"
16437 "\n"
16438 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16439 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16440 " -1: draw box only.\n"
16441 " 0: draw box, ticks, and numeric tick labels.\n"
16442 " 1: also draw coordinate axes at x=0 and y=0.\n"
16443 " 2: also draw a grid at major tick positions in both\n"
16444 " coordinates.\n"
16445 " 3: also draw a grid at minor tick positions in both\n"
16446 " coordinates.\n"
16447 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16448 " have to be converted to logarithms separately.)\n"
16449 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16450 " have to be converted to logarithms separately.)\n"
16451 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16452 " have to be converted to logarithms separately.)\n"
16453 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16454 " have to be converted to logarithms separately.)\n"
16455 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16456 " have to be converted to logarithms separately.)\n"
16457 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16458 " have to be converted to logarithms separately.)\n"
16459 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16460 " have to be converted to logarithms separately.)\n"
16461 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16462 " have to be converted to logarithms separately.)\n"
16463 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16464 " and y data have to be converted to logarithms separately.)\n"
16465 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16466 " and y data have to be converted to logarithms separately.)\n"
16467 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16468 " and y data have to be converted to logarithms separately.)\n"
16469 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16470 " and y data have to be converted to logarithms separately.)\n"
16471 " 40: same as 0 except date / time x labels.\n"
16472 " 41: same as 1 except date / time x labels.\n"
16473 " 42: same as 2 except date / time x labels.\n"
16474 " 43: same as 3 except date / time x labels.\n"
16475 " 50: same as 0 except date / time y labels.\n"
16476 " 51: same as 1 except date / time y labels.\n"
16477 " 52: same as 2 except date / time y labels.\n"
16478 " 53: same as 3 except date / time y labels.\n"
16479 " 60: same as 0 except date / time x and y labels.\n"
16480 " 61: same as 1 except date / time x and y labels.\n"
16481 " 62: same as 2 except date / time x and y labels.\n"
16482 " 63: same as 3 except date / time x and y labels.\n"
16483 " 70: same as 0 except custom x and y labels.\n"
16484 " 71: same as 1 except custom x and y labels.\n"
16485 " 72: same as 2 except custom x and y labels.\n"
16486 " 73: same as 3 except custom x and y labels.\n"
16487 "\n"
16488 ""},
16489 { "plenv0", _wrap_plenv0, METH_VARARGS, "\n"
16490 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16491 "\n"
16492 "DESCRIPTION:\n"
16493 "\n"
16494 " Sets up plotter environment for simple graphs by calling pladv and\n"
16495 " setting up viewport and window to sensible default values. plenv0\n"
16496 " leaves a standard margin (left-hand margin of eight character heights,\n"
16497 " and a margin around the other three sides of five character heights)\n"
16498 " around most graphs for axis labels and a title. When these defaults\n"
16499 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16500 " plvasp for setting up the viewport, plwind for defining the window,\n"
16501 " and plbox for drawing the box.\n"
16502 "\n"
16503 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16504 "\n"
16505 " This function is used in example 21.\n"
16506 "\n"
16507 "\n"
16508 "\n"
16509 "SYNOPSIS:\n"
16510 "\n"
16511 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16512 "\n"
16513 "ARGUMENTS:\n"
16514 "\n"
16515 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16516 " world coordinates).\n"
16517 "\n"
16518 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16519 " world coordinates).\n"
16520 "\n"
16521 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16522 " coordinates).\n"
16523 "\n"
16524 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16525 " coordinates).\n"
16526 "\n"
16527 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16528 " scales will not be set, the user must set up the scale before\n"
16529 " calling plenv0 using plsvpa, plvasp or other.\n"
16530 " 0: the x and y axes are scaled independently to use as much of\n"
16531 " the screen as possible.\n"
16532 " 1: the scales of the x and y axes are made equal.\n"
16533 " 2: the axis of the x and y axes are made equal, and the plot\n"
16534 " box will be square.\n"
16535 "\n"
16536 "\n"
16537 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16538 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16539 " -1: draw box only.\n"
16540 " 0: draw box, ticks, and numeric tick labels.\n"
16541 " 1: also draw coordinate axes at x=0 and y=0.\n"
16542 " 2: also draw a grid at major tick positions in both\n"
16543 " coordinates.\n"
16544 " 3: also draw a grid at minor tick positions in both\n"
16545 " coordinates.\n"
16546 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16547 " have to be converted to logarithms separately.)\n"
16548 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16549 " have to be converted to logarithms separately.)\n"
16550 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16551 " have to be converted to logarithms separately.)\n"
16552 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16553 " have to be converted to logarithms separately.)\n"
16554 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16555 " have to be converted to logarithms separately.)\n"
16556 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16557 " have to be converted to logarithms separately.)\n"
16558 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16559 " have to be converted to logarithms separately.)\n"
16560 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16561 " have to be converted to logarithms separately.)\n"
16562 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16563 " and y data have to be converted to logarithms separately.)\n"
16564 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16565 " and y data have to be converted to logarithms separately.)\n"
16566 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16567 " and y data have to be converted to logarithms separately.)\n"
16568 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16569 " and y data have to be converted to logarithms separately.)\n"
16570 " 40: same as 0 except date / time x labels.\n"
16571 " 41: same as 1 except date / time x labels.\n"
16572 " 42: same as 2 except date / time x labels.\n"
16573 " 43: same as 3 except date / time x labels.\n"
16574 " 50: same as 0 except date / time y labels.\n"
16575 " 51: same as 1 except date / time y labels.\n"
16576 " 52: same as 2 except date / time y labels.\n"
16577 " 53: same as 3 except date / time y labels.\n"
16578 " 60: same as 0 except date / time x and y labels.\n"
16579 " 61: same as 1 except date / time x and y labels.\n"
16580 " 62: same as 2 except date / time x and y labels.\n"
16581 " 63: same as 3 except date / time x and y labels.\n"
16582 " 70: same as 0 except custom x and y labels.\n"
16583 " 71: same as 1 except custom x and y labels.\n"
16584 " 72: same as 2 except custom x and y labels.\n"
16585 " 73: same as 3 except custom x and y labels.\n"
16586 "\n"
16587 ""},
16588 { "pleop", _wrap_pleop, METH_NOARGS, "\n"
16589 "Eject current page\n"
16590 "\n"
16591 "DESCRIPTION:\n"
16592 "\n"
16593 " Clears the graphics screen of an interactive device, or ejects a page\n"
16594 " on a plotter. See plbop for more information.\n"
16595 "\n"
16596 " Redacted form: pleop()\n"
16597 "\n"
16598 " This function is used in example 2,14.\n"
16599 "\n"
16600 "\n"
16601 "\n"
16602 "SYNOPSIS:\n"
16603 "\n"
16604 "pleop()\n"
16605 "\n"
16606 ""},
16607 { "plerrx", _wrap_plerrx, METH_VARARGS, "\n"
16608 "Draw error bars in x direction\n"
16609 "\n"
16610 "DESCRIPTION:\n"
16611 "\n"
16612 " Draws a set of n error bars in x direction, the i'th error bar\n"
16613 " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16614 " of the error bars are of length equal to the minor tick length\n"
16615 " (settable using plsmin).\n"
16616 "\n"
16617 " Redacted form: General: plerrx(xmin, ymax, y)\n"
16618 "\n"
16619 "\n"
16620 " This function is used in example 29.\n"
16621 "\n"
16622 "\n"
16623 "\n"
16624 "SYNOPSIS:\n"
16625 "\n"
16626 "plerrx(n, xmin, xmax, y)\n"
16627 "\n"
16628 "ARGUMENTS:\n"
16629 "\n"
16630 " n (PLINT, input) : Number of error bars to draw.\n"
16631 "\n"
16632 " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16633 " of the left-hand endpoints of the error bars.\n"
16634 "\n"
16635 " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16636 " of the right-hand endpoints of the error bars.\n"
16637 "\n"
16638 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16639 " the error bars.\n"
16640 "\n"
16641 ""},
16642 { "plerry", _wrap_plerry, METH_VARARGS, "\n"
16643 "Draw error bars in the y direction\n"
16644 "\n"
16645 "DESCRIPTION:\n"
16646 "\n"
16647 " Draws a set of n error bars in the y direction, the i'th error bar\n"
16648 " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16649 " of the error bars are of length equal to the minor tick length\n"
16650 " (settable using plsmin).\n"
16651 "\n"
16652 " Redacted form: General: plerry(x, ymin, ymax)\n"
16653 "\n"
16654 "\n"
16655 " This function is used in example 29.\n"
16656 "\n"
16657 "\n"
16658 "\n"
16659 "SYNOPSIS:\n"
16660 "\n"
16661 "plerry(n, x, ymin, ymax)\n"
16662 "\n"
16663 "ARGUMENTS:\n"
16664 "\n"
16665 " n (PLINT, input) : Number of error bars to draw.\n"
16666 "\n"
16667 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16668 " the error bars.\n"
16669 "\n"
16670 " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16671 " of the lower endpoints of the error bars.\n"
16672 "\n"
16673 " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16674 " of the upper endpoints of the error bars.\n"
16675 "\n"
16676 ""},
16677 { "plfamadv", _wrap_plfamadv, METH_NOARGS, "\n"
16678 "Advance to the next family file on the next new page\n"
16679 "\n"
16680 "DESCRIPTION:\n"
16681 "\n"
16682 " Advance to the next family file on the next new page.\n"
16683 "\n"
16684 " Redacted form: plfamadv()\n"
16685 "\n"
16686 " This function is not used in any examples.\n"
16687 "\n"
16688 "\n"
16689 "\n"
16690 "SYNOPSIS:\n"
16691 "\n"
16692 "plfamadv()\n"
16693 "\n"
16694 ""},
16695 { "plfill", _wrap_plfill, METH_VARARGS, "\n"
16696 "Draw filled polygon\n"
16697 "\n"
16698 "DESCRIPTION:\n"
16699 "\n"
16700 " Fills the polygon defined by the n points (\n"
16701 " x[i],\n"
16702 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16703 " style is a solid fill. The routine will automatically close the\n"
16704 " polygon between the last and first vertices. If multiple closed\n"
16705 " polygons are passed in x and y then plfill will fill in between them.\n"
16706 "\n"
16707 " Redacted form: plfill(x,y)\n"
16708 "\n"
16709 " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16710 "\n"
16711 "\n"
16712 "\n"
16713 "SYNOPSIS:\n"
16714 "\n"
16715 "plfill(n, x, y)\n"
16716 "\n"
16717 "ARGUMENTS:\n"
16718 "\n"
16719 " n (PLINT, input) : Number of vertices in polygon.\n"
16720 "\n"
16721 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16722 " vertices.\n"
16723 "\n"
16724 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16725 " vertices.\n"
16726 "\n"
16727 ""},
16728 { "plfill3", _wrap_plfill3, METH_VARARGS, "\n"
16729 "Draw filled polygon in 3D\n"
16730 "\n"
16731 "DESCRIPTION:\n"
16732 "\n"
16733 " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16734 " vectors using the pattern defined by plpsty or plpat. The routine\n"
16735 " will automatically close the polygon between the last and first\n"
16736 " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16737 " plfill3 will fill in between them.\n"
16738 "\n"
16739 " Redacted form: General: plfill3(x, y, z)\n"
16740 "\n"
16741 "\n"
16742 " This function is used in example 15.\n"
16743 "\n"
16744 "\n"
16745 "\n"
16746 "SYNOPSIS:\n"
16747 "\n"
16748 "plfill3(n, x, y, z)\n"
16749 "\n"
16750 "ARGUMENTS:\n"
16751 "\n"
16752 " n (PLINT, input) : Number of vertices in polygon.\n"
16753 "\n"
16754 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16755 " vertices.\n"
16756 "\n"
16757 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16758 " vertices.\n"
16759 "\n"
16760 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16761 " vertices.\n"
16762 "\n"
16763 ""},
16764 { "plgradient", _wrap_plgradient, METH_VARARGS, "\n"
16765 "Draw linear gradient inside polygon\n"
16766 "\n"
16767 "DESCRIPTION:\n"
16768 "\n"
16769 " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16770 " points (\n"
16771 " x[i],\n"
16772 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16773 " polygon coordinates and the gradient angle are all expressed in world\n"
16774 " coordinates. The angle from the x axis for both the rotated\n"
16775 " coordinate system and the gradient vector is specified by angle. The\n"
16776 " magnitude of the gradient vector is the difference between the maximum\n"
16777 " and minimum values of x for the vertices in the rotated coordinate\n"
16778 " system. The origin of the gradient vector can be interpreted as being\n"
16779 " anywhere on the line corresponding to the minimum x value for the\n"
16780 " vertices in the rotated coordinate system. The distance along the\n"
16781 " gradient vector is linearly transformed to the independent variable of\n"
16782 " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16783 " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16784 " color corresponding to the independent variable of cmap1. For more\n"
16785 " information about cmap1 (see the PLplot documentation).\n"
16786 "\n"
16787 " Redacted form: plgradient(x,y,angle)\n"
16788 "\n"
16789 " This function is used in examples 25 and 30.\n"
16790 "\n"
16791 "\n"
16792 "\n"
16793 "SYNOPSIS:\n"
16794 "\n"
16795 "plgradient(n, x, y, angle)\n"
16796 "\n"
16797 "ARGUMENTS:\n"
16798 "\n"
16799 " n (PLINT, input) : Number of vertices in polygon.\n"
16800 "\n"
16801 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16802 " vertices.\n"
16803 "\n"
16804 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16805 " vertices.\n"
16806 "\n"
16807 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16808 " axis.\n"
16809 "\n"
16810 ""},
16811 { "plflush", _wrap_plflush, METH_NOARGS, "\n"
16812 "Flushes the output stream\n"
16813 "\n"
16814 "DESCRIPTION:\n"
16815 "\n"
16816 " Flushes the output stream. Use sparingly, if at all.\n"
16817 "\n"
16818 " Redacted form: plflush()\n"
16819 "\n"
16820 " This function is used in examples 1 and 14.\n"
16821 "\n"
16822 "\n"
16823 "\n"
16824 "SYNOPSIS:\n"
16825 "\n"
16826 "plflush()\n"
16827 "\n"
16828 ""},
16829 { "plfont", _wrap_plfont, METH_O, "\n"
16830 "Set font\n"
16831 "\n"
16832 "DESCRIPTION:\n"
16833 "\n"
16834 " Sets the font used for subsequent text and symbols. For devices that\n"
16835 " still use Hershey fonts this routine has no effect unless the Hershey\n"
16836 " fonts with extended character set are loaded (see plfontld). For\n"
16837 " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16838 " this routine calls the plsfci routine with argument set up\n"
16839 " appropriately for the various cases below. However, this method of\n"
16840 " specifying the font for unicode-aware devices is deprecated, and the\n"
16841 " much more flexible method of calling plsfont directly is recommended\n"
16842 " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16843 "\n"
16844 " Redacted form: plfont(ifont)\n"
16845 "\n"
16846 " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16847 "\n"
16848 "\n"
16849 "\n"
16850 "SYNOPSIS:\n"
16851 "\n"
16852 "plfont(ifont)\n"
16853 "\n"
16854 "ARGUMENTS:\n"
16855 "\n"
16856 " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16857 " (simplest and fastest)\n"
16858 " 2: Serif font\n"
16859 " 3: Italic font\n"
16860 " 4: Script font\n"
16861 "\n"
16862 ""},
16863 { "plfontld", _wrap_plfontld, METH_O, "\n"
16864 "Load Hershey fonts\n"
16865 "\n"
16866 "DESCRIPTION:\n"
16867 "\n"
16868 " Loads the Hershey fonts used for text and symbols. This routine may\n"
16869 " be called before or after initializing PLplot. If not explicitly\n"
16870 " called before PLplot initialization, then by default that\n"
16871 " initialization loads Hershey fonts with the extended character set.\n"
16872 " This routine only has a practical effect for devices that still use\n"
16873 " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16874 " system fonts instead of Hershey fonts).\n"
16875 "\n"
16876 " Redacted form: plfontld(fnt)\n"
16877 "\n"
16878 " This function is used in examples 1 and 7.\n"
16879 "\n"
16880 "\n"
16881 "\n"
16882 "SYNOPSIS:\n"
16883 "\n"
16884 "plfontld(fnt)\n"
16885 "\n"
16886 "ARGUMENTS:\n"
16887 "\n"
16888 " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16889 " A zero value specifies Hershey fonts with the standard character\n"
16890 " set and a non-zero value (the default assumed if plfontld is never\n"
16891 " called) specifies Hershey fonts with the extended character set.\n"
16892 "\n"
16893 ""},
16894 { "plgchr", _wrap_plgchr, METH_NOARGS, "\n"
16895 "Get character default height and current (scaled) height\n"
16896 "\n"
16897 "DESCRIPTION:\n"
16898 "\n"
16899 " Get character default height and current (scaled) height.\n"
16900 "\n"
16901 " Redacted form: plgchr(p_def, p_ht)\n"
16902 "\n"
16903 " This function is used in example 23.\n"
16904 "\n"
16905 "\n"
16906 "\n"
16907 "SYNOPSIS:\n"
16908 "\n"
16909 "plgchr(p_def, p_ht)\n"
16910 "\n"
16911 "ARGUMENTS:\n"
16912 "\n"
16913 " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16914 " character height (mm).\n"
16915 "\n"
16916 " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16917 " character height (mm).\n"
16918 "\n"
16919 ""},
16920 { "plgcol0", _wrap_plgcol0, METH_O, "\n"
16921 "Returns 8-bit RGB values for given color index from cmap0\n"
16922 "\n"
16923 "DESCRIPTION:\n"
16924 "\n"
16925 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16926 " PLplot documentation). Values are negative if an invalid color id is\n"
16927 " given.\n"
16928 "\n"
16929 " Redacted form: plgcol0(icol0, r, g, b)\n"
16930 "\n"
16931 " This function is used in example 2.\n"
16932 "\n"
16933 "\n"
16934 "\n"
16935 "SYNOPSIS:\n"
16936 "\n"
16937 "plgcol0(icol0, r, g, b)\n"
16938 "\n"
16939 "ARGUMENTS:\n"
16940 "\n"
16941 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16942 "\n"
16943 " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16944 " value.\n"
16945 "\n"
16946 " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16947 " value.\n"
16948 "\n"
16949 " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16950 " value.\n"
16951 "\n"
16952 ""},
16953 { "plgcol0a", _wrap_plgcol0a, METH_O, "\n"
16954 "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16955 "\n"
16956 "DESCRIPTION:\n"
16957 "\n"
16958 " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16959 " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16960 " Values are negative if an invalid color id is given.\n"
16961 "\n"
16962 " Redacted form: plgcola(r, g, b)\n"
16963 "\n"
16964 " This function is used in example 30.\n"
16965 "\n"
16966 "\n"
16967 "\n"
16968 "SYNOPSIS:\n"
16969 "\n"
16970 "plgcol0a(icol0, r, g, b, alpha)\n"
16971 "\n"
16972 "ARGUMENTS:\n"
16973 "\n"
16974 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16975 "\n"
16976 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16977 " in the range from 0 to 255.\n"
16978 "\n"
16979 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16980 " in the range from 0 to 255.\n"
16981 "\n"
16982 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16983 " in the range from 0 to 255.\n"
16984 "\n"
16985 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16986 " transparency in the range from (0.0-1.0).\n"
16987 "\n"
16988 ""},
16989 { "plgcolbg", _wrap_plgcolbg, METH_NOARGS, "\n"
16990 "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16991 "\n"
16992 "DESCRIPTION:\n"
16993 "\n"
16994 " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16995 "\n"
16996 " Redacted form: plgcolbg(r, g, b)\n"
16997 "\n"
16998 " This function is used in example 31.\n"
16999 "\n"
17000 "\n"
17001 "\n"
17002 "SYNOPSIS:\n"
17003 "\n"
17004 "plgcolbg(r, g, b)\n"
17005 "\n"
17006 "ARGUMENTS:\n"
17007 "\n"
17008 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
17009 " in the range from 0 to 255.\n"
17010 "\n"
17011 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
17012 " in the range from 0 to 255.\n"
17013 "\n"
17014 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17015 " in the range from 0 to 255.\n"
17016 "\n"
17017 ""},
17018 { "plgcolbga", _wrap_plgcolbga, METH_NOARGS, "\n"
17019 "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
17020 "\n"
17021 "DESCRIPTION:\n"
17022 "\n"
17023 " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
17024 " alpha transparency value.\n"
17025 "\n"
17026 " This function is used in example 31.\n"
17027 "\n"
17028 "\n"
17029 "\n"
17030 "SYNOPSIS:\n"
17031 "\n"
17032 "plgcolbga(r, g, b, alpha)\n"
17033 "\n"
17034 "ARGUMENTS:\n"
17035 "\n"
17036 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
17037 " in the range from 0 to 255.\n"
17038 "\n"
17039 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
17040 " in the range from 0 to 255.\n"
17041 "\n"
17042 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17043 " in the range from 0 to 255.\n"
17044 "\n"
17045 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
17046 " transparency in the range (0.0-1.0).\n"
17047 "\n"
17048 ""},
17049 { "plgcompression", _wrap_plgcompression, METH_NOARGS, "\n"
17050 "Get the current device-compression setting\n"
17051 "\n"
17052 "DESCRIPTION:\n"
17053 "\n"
17054 " Get the current device-compression setting. This parameter is only\n"
17055 " used for drivers that provide compression.\n"
17056 "\n"
17057 " Redacted form: plgcompression(compression)\n"
17058 "\n"
17059 " This function is used in example 31.\n"
17060 "\n"
17061 "\n"
17062 "\n"
17063 "SYNOPSIS:\n"
17064 "\n"
17065 "plgcompression(compression)\n"
17066 "\n"
17067 "ARGUMENTS:\n"
17068 "\n"
17069 " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
17070 " compression setting for the current device.\n"
17071 "\n"
17072 ""},
17073 { "plgdev", _wrap_plgdev, METH_NOARGS, "\n"
17074 "Get the current device (keyword) name\n"
17075 "\n"
17076 "DESCRIPTION:\n"
17077 "\n"
17078 " Get the current device (keyword) name. Note: you must have allocated\n"
17079 " space for this (80 characters is safe).\n"
17080 "\n"
17081 " Redacted form: plgdev(p_dev)\n"
17082 "\n"
17083 " This function is used in example 14.\n"
17084 "\n"
17085 "\n"
17086 "\n"
17087 "SYNOPSIS:\n"
17088 "\n"
17089 "plgdev(p_dev)\n"
17090 "\n"
17091 "ARGUMENTS:\n"
17092 "\n"
17093 " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17094 " (with preallocated length of 80 characters or more) containing the\n"
17095 " device (keyword) name.\n"
17096 "\n"
17097 ""},
17098 { "plgdidev", _wrap_plgdidev, METH_NOARGS, "\n"
17099 "Get parameters that define current device-space window\n"
17100 "\n"
17101 "DESCRIPTION:\n"
17102 "\n"
17103 " Get relative margin width, aspect ratio, and relative justification\n"
17104 " that define current device-space window. If plsdidev has not been\n"
17105 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
17106 " p_jy will all be 0.\n"
17107 "\n"
17108 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17109 "\n"
17110 " This function is used in example 31.\n"
17111 "\n"
17112 "\n"
17113 "\n"
17114 "SYNOPSIS:\n"
17115 "\n"
17116 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17117 "\n"
17118 "ARGUMENTS:\n"
17119 "\n"
17120 " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17121 " margin width.\n"
17122 "\n"
17123 " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
17124 " ratio.\n"
17125 "\n"
17126 " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17127 " justification in x.\n"
17128 "\n"
17129 " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17130 " justification in y.\n"
17131 "\n"
17132 ""},
17133 { "plgdiori", _wrap_plgdiori, METH_NOARGS, "\n"
17134 "Get plot orientation\n"
17135 "\n"
17136 "DESCRIPTION:\n"
17137 "\n"
17138 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
17139 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
17140 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
17141 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
17142 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
17143 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
17144 " not been called the default value pointed to by p_rot will be 0.\n"
17145 "\n"
17146 " Redacted form: plgdiori(p_rot)\n"
17147 "\n"
17148 " This function is not used in any examples.\n"
17149 "\n"
17150 "\n"
17151 "\n"
17152 "SYNOPSIS:\n"
17153 "\n"
17154 "plgdiori(p_rot)\n"
17155 "\n"
17156 "ARGUMENTS:\n"
17157 "\n"
17158 " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
17159 " parameter.\n"
17160 "\n"
17161 ""},
17162 { "plgdiplt", _wrap_plgdiplt, METH_NOARGS, "\n"
17163 "Get parameters that define current plot-space window\n"
17164 "\n"
17165 "DESCRIPTION:\n"
17166 "\n"
17167 " Get relative minima and maxima that define current plot-space window.\n"
17168 " If plsdiplt has not been called the default values pointed to by\n"
17169 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
17170 "\n"
17171 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17172 "\n"
17173 " This function is used in example 31.\n"
17174 "\n"
17175 "\n"
17176 "\n"
17177 "SYNOPSIS:\n"
17178 "\n"
17179 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17180 "\n"
17181 "ARGUMENTS:\n"
17182 "\n"
17183 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17184 " minimum in x.\n"
17185 "\n"
17186 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17187 " minimum in y.\n"
17188 "\n"
17189 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17190 " maximum in x.\n"
17191 "\n"
17192 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17193 " maximum in y.\n"
17194 "\n"
17195 ""},
17196 { "plgfam", _wrap_plgfam, METH_NOARGS, "\n"
17197 "Get family file parameters\n"
17198 "\n"
17199 "DESCRIPTION:\n"
17200 "\n"
17201 " Gets information about current family file, if familying is enabled.\n"
17202 " See the PLplot documentation for more information.\n"
17203 "\n"
17204 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
17205 "\n"
17206 " This function is used in examples 14 and 31.\n"
17207 "\n"
17208 "\n"
17209 "\n"
17210 "SYNOPSIS:\n"
17211 "\n"
17212 "plgfam(p_fam, p_num, p_bmax)\n"
17213 "\n"
17214 "ARGUMENTS:\n"
17215 "\n"
17216 " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17217 " family flag value. If nonzero, familying is enabled for the\n"
17218 " current device.\n"
17219 "\n"
17220 " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17221 " family file number.\n"
17222 "\n"
17223 " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17224 " file size (in bytes) for a family file.\n"
17225 "\n"
17226 ""},
17227 { "plgfci", _wrap_plgfci, METH_NOARGS, "\n"
17228 "Get FCI (font characterization integer)\n"
17229 "\n"
17230 "DESCRIPTION:\n"
17231 "\n"
17232 " Gets information about the current font using the FCI approach. See\n"
17233 " the PLplot documentation for more information.\n"
17234 "\n"
17235 " Redacted form: plgfci(p_fci)\n"
17236 "\n"
17237 " This function is used in example 23.\n"
17238 "\n"
17239 "\n"
17240 "\n"
17241 "SYNOPSIS:\n"
17242 "\n"
17243 "plgfci(p_fci)\n"
17244 "\n"
17245 "ARGUMENTS:\n"
17246 "\n"
17247 " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
17248 " FCI value.\n"
17249 "\n"
17250 ""},
17251 { "plgfnam", _wrap_plgfnam, METH_NOARGS, "\n"
17252 "Get output file name\n"
17253 "\n"
17254 "DESCRIPTION:\n"
17255 "\n"
17256 " Gets the current output file name, if applicable.\n"
17257 "\n"
17258 " Redacted form: plgfnam(fnam)\n"
17259 "\n"
17260 " This function is used in example 31.\n"
17261 "\n"
17262 "\n"
17263 "\n"
17264 "SYNOPSIS:\n"
17265 "\n"
17266 "plgfnam(fnam)\n"
17267 "\n"
17268 "ARGUMENTS:\n"
17269 "\n"
17270 " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17271 " (with preallocated length of 80 characters or more) containing the\n"
17272 " file name.\n"
17273 "\n"
17274 ""},
17275 { "plgfont", _wrap_plgfont, METH_NOARGS, "\n"
17276 "Get family, style and weight of the current font\n"
17277 "\n"
17278 "DESCRIPTION:\n"
17279 "\n"
17280 " Gets information about current font. See the PLplot documentation for\n"
17281 " more information on font selection.\n"
17282 "\n"
17283 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17284 "\n"
17285 " This function is used in example 23.\n"
17286 "\n"
17287 "\n"
17288 "\n"
17289 "SYNOPSIS:\n"
17290 "\n"
17291 "plgfont(p_family, p_style, p_weight)\n"
17292 "\n"
17293 "ARGUMENTS:\n"
17294 "\n"
17295 " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17296 " font family. The available values are given by the PL_FCI_*\n"
17297 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17298 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17299 " p_family is NULL then the font family is not returned.\n"
17300 "\n"
17301 " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17302 " font style. The available values are given by the PL_FCI_*\n"
17303 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17304 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
17305 " style is not returned.\n"
17306 "\n"
17307 " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17308 " font weight. The available values are given by the PL_FCI_*\n"
17309 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17310 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17311 " returned.\n"
17312 "\n"
17313 ""},
17314 { "plglevel", _wrap_plglevel, METH_NOARGS, "\n"
17315 "Get the (current) run level\n"
17316 "\n"
17317 "DESCRIPTION:\n"
17318 "\n"
17319 " Get the (current) run level. Valid settings are: 0, uninitialized\n"
17320 " 1, initialized\n"
17321 " 2, viewport defined\n"
17322 " 3, world coordinates defined\n"
17323 "\n"
17324 "\n"
17325 " Redacted form: plglevel(p_level)\n"
17326 "\n"
17327 " This function is used in example 31.\n"
17328 "\n"
17329 "\n"
17330 "\n"
17331 "SYNOPSIS:\n"
17332 "\n"
17333 "plglevel(p_level)\n"
17334 "\n"
17335 "ARGUMENTS:\n"
17336 "\n"
17337 " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
17338 " level.\n"
17339 "\n"
17340 ""},
17341 { "plgpage", _wrap_plgpage, METH_NOARGS, "\n"
17342 "Get page parameters\n"
17343 "\n"
17344 "DESCRIPTION:\n"
17345 "\n"
17346 " Gets the current page configuration. The length and offset values are\n"
17347 " expressed in units that are specific to the current driver. For\n"
17348 " instance: screen drivers will usually interpret them as number of\n"
17349 " pixels, whereas printer drivers will usually use mm.\n"
17350 "\n"
17351 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17352 "\n"
17353 " This function is used in examples 14 and 31.\n"
17354 "\n"
17355 "\n"
17356 "\n"
17357 "SYNOPSIS:\n"
17358 "\n"
17359 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17360 "\n"
17361 "ARGUMENTS:\n"
17362 "\n"
17363 " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17364 " pixels/inch (DPI) in x.\n"
17365 "\n"
17366 " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17367 " pixels/inch (DPI) in y.\n"
17368 "\n"
17369 " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17370 " length.\n"
17371 "\n"
17372 " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17373 " length.\n"
17374 "\n"
17375 " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17376 " offset.\n"
17377 "\n"
17378 " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17379 " offset.\n"
17380 "\n"
17381 ""},
17382 { "plgra", _wrap_plgra, METH_NOARGS, "\n"
17383 "Switch to graphics screen\n"
17384 "\n"
17385 "DESCRIPTION:\n"
17386 "\n"
17387 " Sets an interactive device to graphics mode, used in conjunction with\n"
17388 " pltext to allow graphics and text to be interspersed. On a device\n"
17389 " which supports separate text and graphics windows, this command causes\n"
17390 " control to be switched to the graphics window. If already in graphics\n"
17391 " mode, this command is ignored. It is also ignored on devices which\n"
17392 " only support a single window or use a different method for shifting\n"
17393 " focus. See also pltext.\n"
17394 "\n"
17395 " Redacted form: plgra()\n"
17396 "\n"
17397 " This function is used in example 1.\n"
17398 "\n"
17399 "\n"
17400 "\n"
17401 "SYNOPSIS:\n"
17402 "\n"
17403 "plgra()\n"
17404 "\n"
17405 ""},
17406 { "plgriddata", _wrap_plgriddata, METH_VARARGS, "\n"
17407 "Grid data from irregularly sampled data\n"
17408 "\n"
17409 "DESCRIPTION:\n"
17410 "\n"
17411 " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
17412 " require data organized as a grid, i.e., with x sample point values\n"
17413 " independent of y coordinate and vice versa. This function takes\n"
17414 " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
17415 " vectors; reads the desired grid location from the input vectors\n"
17416 " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
17417 " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
17418 " interpolate the data to the grid is specified with the argument type\n"
17419 " which can have one parameter specified in argument data.\n"
17420 "\n"
17421 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17422 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17423 "\n"
17424 "\n"
17425 " This function is used in example 21.\n"
17426 "\n"
17427 "\n"
17428 "\n"
17429 "SYNOPSIS:\n"
17430 "\n"
17431 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17432 "\n"
17433 "ARGUMENTS:\n"
17434 "\n"
17435 " x (PLFLT_VECTOR, input) : The input x vector.\n"
17436 "\n"
17437 " y (PLFLT_VECTOR, input) : The input y vector.\n"
17438 "\n"
17439 " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
17440 " y[i], z[i] represents one data sample coordinate.\n"
17441 "\n"
17442 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17443 " vectors.\n"
17444 "\n"
17445 " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17446 " in the x direction. Usually xg has nptsx equally spaced values\n"
17447 " from the minimum to the maximum values of the x input vector.\n"
17448 "\n"
17449 " nptsx (PLINT, input) : The number of points in the xg vector.\n"
17450 "\n"
17451 " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17452 " in the y direction. Similar to the xg parameter.\n"
17453 "\n"
17454 " nptsy (PLINT, input) : The number of points in the yg vector.\n"
17455 "\n"
17456 " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
17457 " where data lies in the grid specified by xg and yg. Therefore the\n"
17458 " zg matrix must be dimensioned\n"
17459 " nptsx by\n"
17460 " nptsy.\n"
17461 "\n"
17462 " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17463 " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17464 " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17465 " GRID_NNI: Natural Neighbors Interpolation\n"
17466 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17467 " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17468 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17469 " Weighted\n"
17470 " For details of the algorithms read the source file plgridd.c.\n"
17471 "\n"
17472 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17473 " which can be specified through this argument. Currently, for\n"
17474 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17475 " use, the lower the value, the noisier (more local) the\n"
17476 " approximation is.\n"
17477 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17478 " range [1. .. 2.]. High values enable the usage of very thin\n"
17479 " triangles for interpolation, possibly resulting in error in\n"
17480 " the approximation.\n"
17481 " GRID_NNI, only weights greater than data will be accepted. If\n"
17482 " 0, all weights will be accepted.\n"
17483 "\n"
17484 ""},
17485 { "plgspa", _wrap_plgspa, METH_NOARGS, "\n"
17486 "Get current subpage parameters\n"
17487 "\n"
17488 "DESCRIPTION:\n"
17489 "\n"
17490 " Gets the size of the current subpage in millimeters measured from the\n"
17491 " bottom left hand corner of the output device page or screen. Can be\n"
17492 " used in conjunction with plsvpa for setting the size of a viewport in\n"
17493 " absolute coordinates (millimeters).\n"
17494 "\n"
17495 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17496 "\n"
17497 " This function is used in example 23.\n"
17498 "\n"
17499 "\n"
17500 "\n"
17501 "SYNOPSIS:\n"
17502 "\n"
17503 "plgspa(xmin, xmax, ymin, ymax)\n"
17504 "\n"
17505 "ARGUMENTS:\n"
17506 "\n"
17507 " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17508 " the left hand edge of the subpage in millimeters.\n"
17509 "\n"
17510 " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17511 " the right hand edge of the subpage in millimeters.\n"
17512 "\n"
17513 " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17514 " the bottom edge of the subpage in millimeters.\n"
17515 "\n"
17516 " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17517 " the top edge of the subpage in millimeters.\n"
17518 "\n"
17519 ""},
17520 { "plgstrm", _wrap_plgstrm, METH_NOARGS, "\n"
17521 "Get current stream number\n"
17522 "\n"
17523 "DESCRIPTION:\n"
17524 "\n"
17525 " Gets the number of the current output stream. See also plsstrm.\n"
17526 "\n"
17527 " Redacted form: plgstrm(p_strm)\n"
17528 "\n"
17529 " This function is used in example 1,20.\n"
17530 "\n"
17531 "\n"
17532 "\n"
17533 "SYNOPSIS:\n"
17534 "\n"
17535 "plgstrm(p_strm)\n"
17536 "\n"
17537 "ARGUMENTS:\n"
17538 "\n"
17539 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17540 " stream value.\n"
17541 "\n"
17542 ""},
17543 { "plgver", _wrap_plgver, METH_NOARGS, "\n"
17544 "Get the current library version number\n"
17545 "\n"
17546 "DESCRIPTION:\n"
17547 "\n"
17548 " Get the current library version number. Note: you must have allocated\n"
17549 " space for this (80 characters is safe).\n"
17550 "\n"
17551 " Redacted form: plgver(p_ver)\n"
17552 "\n"
17553 " This function is used in example 1.\n"
17554 "\n"
17555 "\n"
17556 "\n"
17557 "SYNOPSIS:\n"
17558 "\n"
17559 "plgver(p_ver)\n"
17560 "\n"
17561 "ARGUMENTS:\n"
17562 "\n"
17563 " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17564 " (with preallocated length of 80 characters or more) containing the\n"
17565 " PLplot version number.\n"
17566 "\n"
17567 ""},
17568 { "plgvpd", _wrap_plgvpd, METH_NOARGS, "\n"
17569 "Get viewport limits in normalized device coordinates\n"
17570 "\n"
17571 "DESCRIPTION:\n"
17572 "\n"
17573 " Get viewport limits in normalized device coordinates.\n"
17574 "\n"
17575 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17576 "\n"
17577 "\n"
17578 " This function is used in example 31.\n"
17579 "\n"
17580 "\n"
17581 "\n"
17582 "SYNOPSIS:\n"
17583 "\n"
17584 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17585 "\n"
17586 "ARGUMENTS:\n"
17587 "\n"
17588 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17589 " viewport limit of the normalized device coordinate in x.\n"
17590 "\n"
17591 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17592 " viewport limit of the normalized device coordinate in x.\n"
17593 "\n"
17594 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17595 " viewport limit of the normalized device coordinate in y.\n"
17596 "\n"
17597 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17598 " viewport limit of the normalized device coordinate in y.\n"
17599 "\n"
17600 ""},
17601 { "plgvpw", _wrap_plgvpw, METH_NOARGS, "\n"
17602 "Get viewport limits in world coordinates\n"
17603 "\n"
17604 "DESCRIPTION:\n"
17605 "\n"
17606 " Get viewport limits in world coordinates.\n"
17607 "\n"
17608 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17609 "\n"
17610 "\n"
17611 " This function is used in example 31.\n"
17612 "\n"
17613 "\n"
17614 "\n"
17615 "SYNOPSIS:\n"
17616 "\n"
17617 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17618 "\n"
17619 "ARGUMENTS:\n"
17620 "\n"
17621 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17622 " viewport limit of the world coordinate in x.\n"
17623 "\n"
17624 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17625 " viewport limit of the world coordinate in x.\n"
17626 "\n"
17627 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17628 " viewport limit of the world coordinate in y.\n"
17629 "\n"
17630 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17631 " viewport limit of the world coordinate in y.\n"
17632 "\n"
17633 ""},
17634 { "plgxax", _wrap_plgxax, METH_NOARGS, "\n"
17635 "Get x axis parameters\n"
17636 "\n"
17637 "DESCRIPTION:\n"
17638 "\n"
17639 " Returns current values of the p_digmax and p_digits flags for the x\n"
17640 " axis. p_digits is updated after the plot is drawn, so this routine\n"
17641 " should only be called after the call to plbox (or plbox3) is complete.\n"
17642 " See the PLplot documentation for more information.\n"
17643 "\n"
17644 " Redacted form: plgxax(p_digmax, p_digits)\n"
17645 "\n"
17646 " This function is used in example 31.\n"
17647 "\n"
17648 "\n"
17649 "\n"
17650 "SYNOPSIS:\n"
17651 "\n"
17652 "plgxax(p_digmax, p_digits)\n"
17653 "\n"
17654 "ARGUMENTS:\n"
17655 "\n"
17656 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17657 " number of digits for the x axis. If nonzero, the printed label\n"
17658 " has been switched to a floating-point representation when the\n"
17659 " number of digits exceeds this value.\n"
17660 "\n"
17661 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17662 " number of digits for the numeric labels (x axis) from the last\n"
17663 " plot.\n"
17664 "\n"
17665 ""},
17666 { "plgyax", _wrap_plgyax, METH_NOARGS, "\n"
17667 "Get y axis parameters\n"
17668 "\n"
17669 "DESCRIPTION:\n"
17670 "\n"
17671 " Identical to plgxax, except that arguments are flags for y axis. See\n"
17672 " the description of plgxax for more detail.\n"
17673 "\n"
17674 " Redacted form: plgyax(p_digmax, p_digits)\n"
17675 "\n"
17676 " This function is used in example 31.\n"
17677 "\n"
17678 "\n"
17679 "\n"
17680 "SYNOPSIS:\n"
17681 "\n"
17682 "plgyax(p_digmax, p_digits)\n"
17683 "\n"
17684 "ARGUMENTS:\n"
17685 "\n"
17686 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17687 " number of digits for the y axis. If nonzero, the printed label\n"
17688 " has been switched to a floating-point representation when the\n"
17689 " number of digits exceeds this value.\n"
17690 "\n"
17691 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17692 " number of digits for the numeric labels (y axis) from the last\n"
17693 " plot.\n"
17694 "\n"
17695 ""},
17696 { "plgzax", _wrap_plgzax, METH_NOARGS, "\n"
17697 "Get z axis parameters\n"
17698 "\n"
17699 "DESCRIPTION:\n"
17700 "\n"
17701 " Identical to plgxax, except that arguments are flags for z axis. See\n"
17702 " the description of plgxax for more detail.\n"
17703 "\n"
17704 " Redacted form: plgzax(p_digmax, p_digits)\n"
17705 "\n"
17706 " This function is used in example 31.\n"
17707 "\n"
17708 "\n"
17709 "\n"
17710 "SYNOPSIS:\n"
17711 "\n"
17712 "plgzax(p_digmax, p_digits)\n"
17713 "\n"
17714 "ARGUMENTS:\n"
17715 "\n"
17716 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17717 " number of digits for the z axis. If nonzero, the printed label\n"
17718 " has been switched to a floating-point representation when the\n"
17719 " number of digits exceeds this value.\n"
17720 "\n"
17721 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17722 " number of digits for the numeric labels (z axis) from the last\n"
17723 " plot.\n"
17724 "\n"
17725 ""},
17726 { "plhist", _wrap_plhist, METH_VARARGS, "\n"
17727 "Plot a histogram from unbinned data\n"
17728 "\n"
17729 "DESCRIPTION:\n"
17730 "\n"
17731 " Plots a histogram from n data points stored in the data vector. This\n"
17732 " routine bins the data into nbin bins equally spaced between datmin and\n"
17733 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17734 " opt allows, among other things, the histogram either to be plotted in\n"
17735 " an existing window or causes plhist to call plenv with suitable limits\n"
17736 " before plotting the histogram.\n"
17737 "\n"
17738 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17739 "\n"
17740 " This function is used in example 5.\n"
17741 "\n"
17742 "\n"
17743 "\n"
17744 "SYNOPSIS:\n"
17745 "\n"
17746 "plhist(n, data, datmin, datmax, nbin, opt)\n"
17747 "\n"
17748 "ARGUMENTS:\n"
17749 "\n"
17750 " n (PLINT, input) : Number of data points.\n"
17751 "\n"
17752 " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17753 " n data points.\n"
17754 "\n"
17755 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17756 "\n"
17757 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17758 "\n"
17759 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17760 " divide the interval xmin to xmax.\n"
17761 "\n"
17762 " opt (PLINT, input) : Is a combination of several flags:\n"
17763 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17764 " the histogram data, the outer bins are expanded to fill up the\n"
17765 " entire x-axis, data outside the given extremes are assigned to the\n"
17766 " outer bins and bins of zero height are simply drawn.\n"
17767 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17768 " to fit the histogram data, without this flag, plenv is called\n"
17769 " to set the world coordinates.\n"
17770 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17771 " extremes are not taken into account. This option should\n"
17772 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17773 " properly present the data.\n"
17774 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17775 " size as the ones inside.\n"
17776 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17777 " (there is a gap for such bins).\n"
17778 "\n"
17779 ""},
17780 { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, "\n"
17781 "Convert HLS color to RGB\n"
17782 "\n"
17783 "DESCRIPTION:\n"
17784 "\n"
17785 " Convert HLS color coordinates to RGB.\n"
17786 "\n"
17787 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17788 "\n"
17789 "\n"
17790 " This function is used in example 2.\n"
17791 "\n"
17792 "\n"
17793 "\n"
17794 "SYNOPSIS:\n"
17795 "\n"
17796 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17797 "\n"
17798 "ARGUMENTS:\n"
17799 "\n"
17800 " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17801 " cylinder.\n"
17802 "\n"
17803 " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17804 " the axis of the color cylinder.\n"
17805 "\n"
17806 " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17807 " the radius of the color cylinder.\n"
17808 "\n"
17809 " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17810 " (0.0-1.0) of the color.\n"
17811 "\n"
17812 " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17813 " intensity (0.0-1.0) of the color.\n"
17814 "\n"
17815 " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17816 " intensity (0.0-1.0) of the color.\n"
17817 "\n"
17818 ""},
17819 { "plinit", _wrap_plinit, METH_NOARGS, "\n"
17820 "Initialize PLplot\n"
17821 "\n"
17822 "DESCRIPTION:\n"
17823 "\n"
17824 " Initializing the plotting package. The program prompts for the device\n"
17825 " keyword or number of the desired output device. Hitting a RETURN in\n"
17826 " response to the prompt is the same as selecting the first device.\n"
17827 " plinit will issue no prompt if either the device was specified\n"
17828 " previously (via command line flag, the plsetopt function, or the\n"
17829 " plsdev function), or if only one device is enabled when PLplot is\n"
17830 " installed. If subpages have been specified, the output device is\n"
17831 " divided into nx by ny subpages, each of which may be used\n"
17832 " independently. If plinit is called again during a program, the\n"
17833 " previously opened file will be closed. The subroutine pladv is used\n"
17834 " to advance from one subpage to the next.\n"
17835 "\n"
17836 " Redacted form: plinit()\n"
17837 "\n"
17838 " This function is used in all of the examples.\n"
17839 "\n"
17840 "\n"
17841 "\n"
17842 "SYNOPSIS:\n"
17843 "\n"
17844 "plinit()\n"
17845 "\n"
17846 ""},
17847 { "pljoin", _wrap_pljoin, METH_VARARGS, "\n"
17848 "Draw a line between two points\n"
17849 "\n"
17850 "DESCRIPTION:\n"
17851 "\n"
17852 " Joins the point (\n"
17853 " x1,\n"
17854 " y1) to (\n"
17855 " x2,\n"
17856 " y2).\n"
17857 "\n"
17858 " Redacted form: pljoin(x1,y1,x2,y2)\n"
17859 "\n"
17860 " This function is used in examples 3 and 14.\n"
17861 "\n"
17862 "\n"
17863 "\n"
17864 "SYNOPSIS:\n"
17865 "\n"
17866 "pljoin(x1, y1, x2, y2)\n"
17867 "\n"
17868 "ARGUMENTS:\n"
17869 "\n"
17870 " x1 (PLFLT, input) : x coordinate of first point.\n"
17871 "\n"
17872 " y1 (PLFLT, input) : y coordinate of first point.\n"
17873 "\n"
17874 " x2 (PLFLT, input) : x coordinate of second point.\n"
17875 "\n"
17876 " y2 (PLFLT, input) : y coordinate of second point.\n"
17877 "\n"
17878 ""},
17879 { "pllab", _wrap_pllab, METH_VARARGS, "\n"
17880 "Simple routine to write labels\n"
17881 "\n"
17882 "DESCRIPTION:\n"
17883 "\n"
17884 " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17885 "\n"
17886 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17887 "\n"
17888 " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17889 "\n"
17890 "\n"
17891 "\n"
17892 "SYNOPSIS:\n"
17893 "\n"
17894 "pllab(xlabel, ylabel, tlabel)\n"
17895 "\n"
17896 "ARGUMENTS:\n"
17897 "\n"
17898 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17899 " the label for the x axis.\n"
17900 "\n"
17901 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17902 " the label for the y axis.\n"
17903 "\n"
17904 " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17905 " the title of the plot.\n"
17906 "\n"
17907 ""},
17908 { "pllegend", _wrap_pllegend, METH_VARARGS, "\n"
17909 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17910 "\n"
17911 "DESCRIPTION:\n"
17912 "\n"
17913 " Routine for creating a discrete plot legend with a plotted filled box,\n"
17914 " line, and/or line of symbols for each annotated legend entry. (See\n"
17915 " plcolorbar for similar functionality for creating continuous color\n"
17916 " bars.) The arguments of pllegend provide control over the location\n"
17917 " and size of the legend as well as the location and characteristics of\n"
17918 " the elements (most of which are optional) within that legend. The\n"
17919 " resulting legend is clipped at the boundaries of the current subpage.\n"
17920 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17921 " defined in the documentation of the position parameter.)\n"
17922 "\n"
17923 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17924 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17925 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17926 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17927 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17928 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17929 "\n"
17930 " This function is used in examples 4, 26, and 33.\n"
17931 "\n"
17932 "\n"
17933 "\n"
17934 "SYNOPSIS:\n"
17935 "\n"
17936 "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"
17937 "\n"
17938 "ARGUMENTS:\n"
17939 "\n"
17940 " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17941 " legend width in adopted coordinates. This quantity is calculated\n"
17942 " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17943 " the routine depending on nlegend and nrow), and the length\n"
17944 " (calculated internally) of the longest text string.\n"
17945 "\n"
17946 " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17947 " legend height in adopted coordinates. This quantity is calculated\n"
17948 " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17949 " the routine depending on nlegend and nrow).\n"
17950 "\n"
17951 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17952 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17953 " on the left of the legend and the plotted area on the right.\n"
17954 " Otherwise, put the text area on the right of the legend and the\n"
17955 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17956 " plot a (semitransparent) background for the legend. If the\n"
17957 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17958 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17959 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17960 " plot the resulting array of legend entries in row-major order.\n"
17961 " Otherwise, plot the legend entries in column-major order.\n"
17962 "\n"
17963 " position (PLINT, input) : position contains bits which control the\n"
17964 " overall position of the legend and the definition of the adopted\n"
17965 " coordinates used for positions just like what is done for the\n"
17966 " position argument for plcolorbar. However, note that the defaults\n"
17967 " for the position bits (see below) are different than the\n"
17968 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17969 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17970 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17971 " the 16 possible standard positions (the 4 corners and centers of\n"
17972 " the 4 sides for both the inside and outside cases) of the legend\n"
17973 " relative to the adopted coordinate system. The corner positions\n"
17974 " are specified by the appropriate combination of two of the\n"
17975 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17976 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17977 " value of one of those bits. The adopted coordinates are\n"
17978 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17979 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17980 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17981 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17982 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17983 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17984 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17985 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17986 "\n"
17987 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17988 " coordinates from the specified standard position of the legend.\n"
17989 " For positive x, the direction of motion away from the standard\n"
17990 " position is inward/outward from the standard corner positions or\n"
17991 " standard left or right positions if the\n"
17992 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17993 " For the standard top or bottom positions, the direction of motion\n"
17994 " is toward positive X.\n"
17995 "\n"
17996 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17997 " coordinates from the specified standard position of the legend.\n"
17998 " For positive y, the direction of motion away from the standard\n"
17999 " position is inward/outward from the standard corner positions or\n"
18000 " standard top or bottom positions if the\n"
18001 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
18002 " the standard left or right positions, the direction of motion is\n"
18003 " toward positive Y.\n"
18004 "\n"
18005 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
18006 " of the plot area (where the colored boxes, lines, and/or lines of\n"
18007 " symbols are drawn) of the legend.\n"
18008 "\n"
18009 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18010 " legend (PL_LEGEND_BACKGROUND).\n"
18011 "\n"
18012 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18013 " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
18014 "\n"
18015 " bb_style (PLINT, input) : The pllsty style number for the\n"
18016 " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
18017 "\n"
18018 " nrow (PLINT, input) : The number of rows in the matrix used to\n"
18019 " render the\n"
18020 " nlegend legend entries. For internal transformations of\n"
18021 " nrow, see further remarks under\n"
18022 " nlegend.\n"
18023 "\n"
18024 " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
18025 " to render the\n"
18026 " nlegend legend entries. For internal transformations of\n"
18027 " ncolumn, see further remarks under\n"
18028 " nlegend.\n"
18029 "\n"
18030 " nlegend (PLINT, input) : Number of legend entries. The above\n"
18031 " nrow and\n"
18032 " ncolumn values are transformed internally to be consistent with\n"
18033 " nlegend. If either\n"
18034 " nrow or\n"
18035 " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
18036 " of\n"
18037 " nrow and\n"
18038 " ncolumn is less than\n"
18039 " nlegend, the smaller of the two (or\n"
18040 " nrow, if\n"
18041 " nrow ==\n"
18042 " ncolumn) is increased so the product is >=\n"
18043 " nlegend. Thus, for example, the common\n"
18044 " nrow = 0,\n"
18045 " ncolumn = 0 case is transformed internally to\n"
18046 " nrow =\n"
18047 " nlegend,\n"
18048 " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
18049 " column.\n"
18050 "\n"
18051 " opt_array (PLINT_VECTOR, input) : A vector of\n"
18052 " nlegend values of options to control each individual plotted area\n"
18053 " corresponding to a legend entry. If the\n"
18054 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
18055 " area. If the\n"
18056 " PL_LEGEND_COLOR_BOX,\n"
18057 " PL_LEGEND_LINE, and/or\n"
18058 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
18059 " entry is plotted with a colored box; a line; and/or a line of\n"
18060 " symbols.\n"
18061 "\n"
18062 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
18063 " area in units of character width.\n"
18064 "\n"
18065 " text_scale (PLFLT, input) : Character height scale for text\n"
18066 " annotations.\n"
18067 "\n"
18068 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
18069 " character height from one legend entry to the next.\n"
18070 "\n"
18071 " text_justification (PLFLT, input) : Justification parameter used\n"
18072 " for text justification. The most common values of\n"
18073 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
18074 " is left justified, centred, or right justified within the text\n"
18075 " area, but other values are allowed as well.\n"
18076 "\n"
18077 " text_colors (PLINT_VECTOR, input) : A vector containing\n"
18078 " nlegend cmap0 text colors.\n"
18079 "\n"
18080 " text (PLCHAR_MATRIX, input) : A vector of\n"
18081 " nlegend UTF-8 character strings containing the legend annotations.\n"
18082 "\n"
18083 " box_colors (PLINT_VECTOR, input) : A vector containing\n"
18084 " nlegend cmap0 colors for the discrete colored boxes (\n"
18085 " PL_LEGEND_COLOR_BOX).\n"
18086 "\n"
18087 " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
18088 " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
18089 " PL_LEGEND_COLOR_BOX).\n"
18090 "\n"
18091 " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
18092 " nlegend scales (units of fraction of character height) for the height\n"
18093 " of the discrete colored boxes (\n"
18094 " PL_LEGEND_COLOR_BOX).\n"
18095 "\n"
18096 " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18097 " nlegend line widths for the patterns specified by box_patterns (\n"
18098 " PL_LEGEND_COLOR_BOX).\n"
18099 "\n"
18100 " line_colors (PLINT_VECTOR, input) : A vector containing\n"
18101 " nlegend cmap0 line colors (\n"
18102 " PL_LEGEND_LINE).\n"
18103 "\n"
18104 " line_styles (PLINT_VECTOR, input) : A vector containing\n"
18105 " nlegend line styles (plsty indices) (\n"
18106 " PL_LEGEND_LINE).\n"
18107 "\n"
18108 " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18109 " nlegend line widths (\n"
18110 " PL_LEGEND_LINE).\n"
18111 "\n"
18112 " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
18113 " nlegend cmap0 symbol colors (\n"
18114 " PL_LEGEND_SYMBOL).\n"
18115 "\n"
18116 " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
18117 " nlegend scale values for the symbol height (\n"
18118 " PL_LEGEND_SYMBOL).\n"
18119 "\n"
18120 " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
18121 " nlegend numbers of symbols to be drawn across the width of the plotted\n"
18122 " area (\n"
18123 " PL_LEGEND_SYMBOL).\n"
18124 "\n"
18125 " symbols (PLCHAR_MATRIX, input) : A vector of\n"
18126 " nlegend UTF-8 character strings containing the legend symbols. (\n"
18127 " PL_LEGEND_SYMBOL).\n"
18128 "\n"
18129 ""},
18130 { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, "\n"
18131 "Plot color bar for image, shade or gradient plots\n"
18132 "\n"
18133 "DESCRIPTION:\n"
18134 "\n"
18135 " Routine for creating a continuous color bar for image, shade, or\n"
18136 " gradient plots. (See pllegend for similar functionality for creating\n"
18137 " legends with discrete elements). The arguments of plcolorbar provide\n"
18138 " control over the location and size of the color bar as well as the\n"
18139 " location and characteristics of the elements (most of which are\n"
18140 " optional) within that color bar. The resulting color bar is clipped\n"
18141 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
18142 " system used for some of the parameters is defined in the documentation\n"
18143 " of the position parameter.)\n"
18144 "\n"
18145 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
18146 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
18147 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
18148 " labels, axis_opts, ticks, sub_ticks, values)\n"
18149 "\n"
18150 " This function is used in examples 16 and 33.\n"
18151 "\n"
18152 "\n"
18153 "\n"
18154 "SYNOPSIS:\n"
18155 "\n"
18156 "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"
18157 "\n"
18158 "ARGUMENTS:\n"
18159 "\n"
18160 " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18161 " labelled and decorated color bar width in adopted coordinates.\n"
18162 "\n"
18163 " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18164 " labelled and decorated color bar height in adopted coordinates.\n"
18165 "\n"
18166 " opt (PLINT, input) : opt contains bits controlling the overall\n"
18167 " color bar. The orientation (direction of the maximum value) of\n"
18168 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
18169 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
18170 " specified, the default orientation is toward the top if the\n"
18171 " colorbar is placed on the left or right of the viewport or toward\n"
18172 " the right if the colorbar is placed on the top or bottom of the\n"
18173 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
18174 " (semitransparent) background for the color bar. If the\n"
18175 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
18176 " color bar. The type of color bar must be specified with one of\n"
18177 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
18178 " more than one of those bits is set only the first one in the above\n"
18179 " list is honored. The position of the (optional) label/title can be\n"
18180 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
18181 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
18182 " will be drawn. If more than one of this list of bits is specified,\n"
18183 " only the first one on the list is honored. End-caps for the color\n"
18184 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
18185 " If a particular color bar cap option is not specified then no cap\n"
18186 " will be drawn for that end. As a special case for\n"
18187 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
18188 " specified. If this option is provided then any tick marks and tick\n"
18189 " labels will be placed at the breaks between shaded segments. TODO:\n"
18190 " This should be expanded to support custom placement of tick marks\n"
18191 " and tick labels at custom value locations for any color bar type.\n"
18192 "\n"
18193 " position (PLINT, input) : position contains bits which control the\n"
18194 " overall position of the color bar and the definition of the\n"
18195 " adopted coordinates used for positions just like what is done for\n"
18196 " the position argument for pllegend. However, note that the\n"
18197 " defaults for the position bits (see below) are different than the\n"
18198 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
18199 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
18200 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
18201 " the 16 possible standard positions (the 4 corners and centers of\n"
18202 " the 4 sides for both the inside and outside cases) of the color\n"
18203 " bar relative to the adopted coordinate system. The corner\n"
18204 " positions are specified by the appropriate combination of two of\n"
18205 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
18206 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
18207 " value of one of those bits. The adopted coordinates are\n"
18208 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
18209 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
18210 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
18211 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
18212 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
18213 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
18214 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
18215 " PL_POSITION_VIEWPORT.\n"
18216 "\n"
18217 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
18218 " coordinates from the specified standard position of the color bar.\n"
18219 " For positive x, the direction of motion away from the standard\n"
18220 " position is inward/outward from the standard corner positions or\n"
18221 " standard left or right positions if the\n"
18222 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18223 " For the standard top or bottom positions, the direction of motion\n"
18224 " is toward positive X.\n"
18225 "\n"
18226 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
18227 " coordinates from the specified standard position of the color bar.\n"
18228 " For positive y, the direction of motion away from the standard\n"
18229 " position is inward/outward from the standard corner positions or\n"
18230 " standard top or bottom positions if the\n"
18231 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18232 " For the standard left or right positions, the direction of motion\n"
18233 " is toward positive Y.\n"
18234 "\n"
18235 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
18236 " the X direction in adopted coordinates.\n"
18237 "\n"
18238 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
18239 " the Y direction in adopted coordinates.\n"
18240 "\n"
18241 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18242 " color bar (PL_COLORBAR_BACKGROUND).\n"
18243 "\n"
18244 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18245 " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
18246 "\n"
18247 " bb_style (PLINT, input) : The pllsty style number for the\n"
18248 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
18249 "\n"
18250 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
18251 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
18252 "\n"
18253 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
18254 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
18255 "\n"
18256 " cont_color (PLINT, input) : The cmap0 contour color for\n"
18257 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
18258 " it will be interpreted according to the design of plshades.\n"
18259 "\n"
18260 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18261 " plots. This is passed directly to plshades, so it will be\n"
18262 " interpreted according to the design of plshades.\n"
18263 "\n"
18264 " n_labels (PLINT, input) : Number of labels to place around the\n"
18265 " color bar.\n"
18266 "\n"
18267 " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
18268 " n_labels labels.\n"
18269 "\n"
18270 " labels (PLCHAR_MATRIX, input) : A vector of\n"
18271 " n_labels UTF-8 character strings containing the labels for the color\n"
18272 " bar. Ignored if no label position is specified with one of the\n"
18273 " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18274 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18275 " corresponding label_opts field.\n"
18276 "\n"
18277 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18278 " value must be greater than 0. It is typically 1 (numerical axis\n"
18279 " labels are provided for one of the long edges of the color bar),\n"
18280 " but it can be larger if multiple numerical axis labels for the\n"
18281 " long edges of the color bar are desired.\n"
18282 "\n"
18283 " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
18284 " n_axes ascii character strings containing options (interpreted as for\n"
18285 " plbox) for the color bar's axis definitions.\n"
18286 "\n"
18287 " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
18288 " spacing of the major tick marks (interpreted as for plbox) for the\n"
18289 " color bar's axis definitions.\n"
18290 "\n"
18291 " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
18292 " number of subticks (interpreted as for plbox) for the color bar's\n"
18293 " axis definitions.\n"
18294 "\n"
18295 " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
18296 " elements in each of the n_axes rows of the values matrix.\n"
18297 "\n"
18298 " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
18299 " values for the data range represented by the color bar. For a row\n"
18300 " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
18301 " elements in the row is specified by n_values[i_axis]. For\n"
18302 " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
18303 " is 2, and the corresponding row elements of the values matrix are\n"
18304 " the minimum and maximum value represented by the colorbar. For\n"
18305 " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
18306 " of the values matrix is interpreted the same as the nlevel and\n"
18307 " clevel arguments of plshades.\n"
18308 "\n"
18309 ""},
18310 { "pllightsource", _wrap_pllightsource, METH_VARARGS, "\n"
18311 "Sets the 3D position of the light source\n"
18312 "\n"
18313 "DESCRIPTION:\n"
18314 "\n"
18315 " Sets the 3D position of the light source for use with plsurf3d and\n"
18316 " plsurf3dl\n"
18317 "\n"
18318 " Redacted form: pllightsource(x, y, z)\n"
18319 "\n"
18320 " This function is used in example 8.\n"
18321 "\n"
18322 "\n"
18323 "\n"
18324 "SYNOPSIS:\n"
18325 "\n"
18326 "pllightsource(x, y, z)\n"
18327 "\n"
18328 "ARGUMENTS:\n"
18329 "\n"
18330 " x (PLFLT, input) : X-coordinate of the light source.\n"
18331 "\n"
18332 " y (PLFLT, input) : Y-coordinate of the light source.\n"
18333 "\n"
18334 " z (PLFLT, input) : Z-coordinate of the light source.\n"
18335 "\n"
18336 ""},
18337 { "plline", _wrap_plline, METH_VARARGS, "\n"
18338 "Draw a line\n"
18339 "\n"
18340 "DESCRIPTION:\n"
18341 "\n"
18342 " Draws line defined by n points in x and y.\n"
18343 "\n"
18344 " Redacted form: plline(x, y)\n"
18345 "\n"
18346 " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
18347 " 25-27, and 29.\n"
18348 "\n"
18349 "\n"
18350 "\n"
18351 "SYNOPSIS:\n"
18352 "\n"
18353 "plline(n, x, y)\n"
18354 "\n"
18355 "ARGUMENTS:\n"
18356 "\n"
18357 " n (PLINT, input) : Number of points defining line.\n"
18358 "\n"
18359 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18360 " points.\n"
18361 "\n"
18362 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18363 " points.\n"
18364 "\n"
18365 ""},
18366 { "plline3", _wrap_plline3, METH_VARARGS, "\n"
18367 "Draw a line in 3 space\n"
18368 "\n"
18369 "DESCRIPTION:\n"
18370 "\n"
18371 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18372 " first set up the viewport, the 2d viewing window (in world\n"
18373 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18374 " more info.\n"
18375 "\n"
18376 " Redacted form: plline3(x, y, z)\n"
18377 "\n"
18378 " This function is used in example 18.\n"
18379 "\n"
18380 "\n"
18381 "\n"
18382 "SYNOPSIS:\n"
18383 "\n"
18384 "plline3(n, x, y, z)\n"
18385 "\n"
18386 "ARGUMENTS:\n"
18387 "\n"
18388 " n (PLINT, input) : Number of points defining line.\n"
18389 "\n"
18390 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18391 " points.\n"
18392 "\n"
18393 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18394 " points.\n"
18395 "\n"
18396 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18397 " points.\n"
18398 "\n"
18399 ""},
18400 { "pllsty", _wrap_pllsty, METH_O, "\n"
18401 "Select line style\n"
18402 "\n"
18403 "DESCRIPTION:\n"
18404 "\n"
18405 " This sets the line style according to one of eight predefined patterns\n"
18406 " (also see plstyl).\n"
18407 "\n"
18408 " Redacted form: pllsty(lin)\n"
18409 "\n"
18410 " This function is used in examples 9, 12, 22, and 25.\n"
18411 "\n"
18412 "\n"
18413 "\n"
18414 "SYNOPSIS:\n"
18415 "\n"
18416 "pllsty(lin)\n"
18417 "\n"
18418 "ARGUMENTS:\n"
18419 "\n"
18420 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18421 " a continuous line, line style 2 is a line with short dashes and\n"
18422 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18423 " 4 has long dashes and short gaps and so on.\n"
18424 "\n"
18425 ""},
18426 { "plmesh", _wrap_plmesh, METH_VARARGS, "\n"
18427 "Plot surface mesh\n"
18428 "\n"
18429 "DESCRIPTION:\n"
18430 "\n"
18431 " Plots a surface mesh within the environment set up by plw3d. The\n"
18432 " surface is defined by the matrix z[\n"
18433 " nx][\n"
18434 " ny] , the point z[i][j] being the value of the function at (\n"
18435 " x[i],\n"
18436 " y[j]). Note that the points in vectors x and y do not need to be\n"
18437 " equally spaced, but must be stored in ascending order. The parameter\n"
18438 " opt controls the way in which the surface is displayed. For further\n"
18439 " details see the PLplot documentation.\n"
18440 "\n"
18441 " Redacted form: plmesh(x, y, z, opt)\n"
18442 "\n"
18443 " This function is used in example 11.\n"
18444 "\n"
18445 "\n"
18446 "\n"
18447 "SYNOPSIS:\n"
18448 "\n"
18449 "plmesh(x, y, z, nx, ny, opt)\n"
18450 "\n"
18451 "ARGUMENTS:\n"
18452 "\n"
18453 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18454 " which the function is evaluated.\n"
18455 "\n"
18456 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18457 " which the function is evaluated.\n"
18458 "\n"
18459 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18460 " plot. Should have dimensions of\n"
18461 " nx by\n"
18462 " ny.\n"
18463 "\n"
18464 " nx (PLINT, input) : Number of x values at which function has been\n"
18465 " evaluated.\n"
18466 "\n"
18467 " ny (PLINT, input) : Number of y values at which function has been\n"
18468 " evaluated.\n"
18469 "\n"
18470 " opt (PLINT, input) : Determines the way in which the surface is\n"
18471 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18472 " function of x for each value of y[j] .\n"
18473 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18474 " for each value of x[i] .\n"
18475 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18476 " at which function is defined.\n"
18477 "\n"
18478 ""},
18479 { "plmeshc", _wrap_plmeshc, METH_VARARGS, "\n"
18480 "Magnitude colored plot surface mesh with contour\n"
18481 "\n"
18482 "DESCRIPTION:\n"
18483 "\n"
18484 " A more powerful form of plmesh: the surface mesh can be colored\n"
18485 " accordingly to the current z value being plotted, a contour plot can\n"
18486 " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18487 " plotted function border and the base XY plane.\n"
18488 "\n"
18489 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18490 "\n"
18491 " This function is used in example 11.\n"
18492 "\n"
18493 "\n"
18494 "\n"
18495 "SYNOPSIS:\n"
18496 "\n"
18497 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18498 "\n"
18499 "ARGUMENTS:\n"
18500 "\n"
18501 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18502 " which the function is evaluated.\n"
18503 "\n"
18504 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18505 " which the function is evaluated.\n"
18506 "\n"
18507 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18508 " plot. Should have dimensions of\n"
18509 " nx by\n"
18510 " ny.\n"
18511 "\n"
18512 " nx (PLINT, input) : Number of x values at which function is\n"
18513 " evaluated.\n"
18514 "\n"
18515 " ny (PLINT, input) : Number of y values at which function is\n"
18516 " evaluated.\n"
18517 "\n"
18518 " opt (PLINT, input) : Determines the way in which the surface is\n"
18519 " represented. To specify more than one option just add the options,\n"
18520 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18521 " showing z as a function of x for each value of y[j] .\n"
18522 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18523 " for each value of x[i] .\n"
18524 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18525 " at which function is defined.\n"
18526 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18527 " the z value being plotted. The color is used from the current\n"
18528 " cmap1.\n"
18529 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18530 " using parameters\n"
18531 " nlevel and\n"
18532 " clevel.\n"
18533 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18534 " the borders of the plotted function.\n"
18535 "\n"
18536 "\n"
18537 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18538 " levels.\n"
18539 "\n"
18540 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18541 "\n"
18542 ""},
18543 { "plmkstrm", _wrap_plmkstrm, METH_NOARGS, "\n"
18544 "Creates a new stream and makes it the default\n"
18545 "\n"
18546 "DESCRIPTION:\n"
18547 "\n"
18548 " Creates a new stream and makes it the default. Differs from using\n"
18549 " plsstrm, in that a free stream number is found, and returned.\n"
18550 " Unfortunately, I have to start at stream 1 and work upward, since\n"
18551 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18552 " that no initial, library-opening call is required. So stream 0 must\n"
18553 " be preallocated, and there is no simple way of determining whether it\n"
18554 " is already in use or not.\n"
18555 "\n"
18556 " Redacted form: plmkstrm(p_strm)\n"
18557 "\n"
18558 " This function is used in examples 1 and 20.\n"
18559 "\n"
18560 "\n"
18561 "\n"
18562 "SYNOPSIS:\n"
18563 "\n"
18564 "plmkstrm(p_strm)\n"
18565 "\n"
18566 "ARGUMENTS:\n"
18567 "\n"
18568 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18569 " number of the created stream.\n"
18570 "\n"
18571 ""},
18572 { "plmtex", _wrap_plmtex, METH_VARARGS, "\n"
18573 "Write text relative to viewport boundaries\n"
18574 "\n"
18575 "DESCRIPTION:\n"
18576 "\n"
18577 " Writes text at a specified position relative to the viewport\n"
18578 " boundaries. Text may be written inside or outside the viewport, but\n"
18579 " is clipped at the subpage boundaries. The reference point of a string\n"
18580 " lies along a line passing through the string at half the height of a\n"
18581 " capital letter. The position of the reference point along this line\n"
18582 " is determined by just, and the position of the reference point\n"
18583 " relative to the viewport is set by disp and pos.\n"
18584 "\n"
18585 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18586 "\n"
18587 "\n"
18588 " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18589 " 26.\n"
18590 "\n"
18591 "\n"
18592 "\n"
18593 "SYNOPSIS:\n"
18594 "\n"
18595 "plmtex(side, disp, pos, just, text)\n"
18596 "\n"
18597 "ARGUMENTS:\n"
18598 "\n"
18599 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18600 " the side of the viewport along which the text is to be written.\n"
18601 " The string must be one of: b: Bottom of viewport, text written\n"
18602 " parallel to edge.\n"
18603 " bv: Bottom of viewport, text written at right angles to edge.\n"
18604 " l: Left of viewport, text written parallel to edge.\n"
18605 " lv: Left of viewport, text written at right angles to edge.\n"
18606 " r: Right of viewport, text written parallel to edge.\n"
18607 " rv: Right of viewport, text written at right angles to edge.\n"
18608 " t: Top of viewport, text written parallel to edge.\n"
18609 " tv: Top of viewport, text written at right angles to edge.\n"
18610 "\n"
18611 "\n"
18612 " disp (PLFLT, input) : Position of the reference point of string,\n"
18613 " measured outwards from the specified viewport edge in units of the\n"
18614 " current character height. Use negative disp to write within the\n"
18615 " viewport.\n"
18616 "\n"
18617 " pos (PLFLT, input) : Position of the reference point of string\n"
18618 " along the specified edge, expressed as a fraction of the length of\n"
18619 " the edge.\n"
18620 "\n"
18621 " just (PLFLT, input) : Specifies the position of the string relative\n"
18622 " to its reference point. If just=0. , the reference point is at\n"
18623 " the left and if just=1. , it is at the right of the string. Other\n"
18624 " values of just give intermediate justifications.\n"
18625 "\n"
18626 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18627 " written out.\n"
18628 "\n"
18629 ""},
18630 { "plmtex3", _wrap_plmtex3, METH_VARARGS, "\n"
18631 "Write text relative to viewport boundaries in 3D plots\n"
18632 "\n"
18633 "DESCRIPTION:\n"
18634 "\n"
18635 " Writes text at a specified position relative to the viewport\n"
18636 " boundaries. Text may be written inside or outside the viewport, but\n"
18637 " is clipped at the subpage boundaries. The reference point of a string\n"
18638 " lies along a line passing through the string at half the height of a\n"
18639 " capital letter. The position of the reference point along this line\n"
18640 " is determined by just, and the position of the reference point\n"
18641 " relative to the viewport is set by disp and pos.\n"
18642 "\n"
18643 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18644 "\n"
18645 " This function is used in example 28.\n"
18646 "\n"
18647 "\n"
18648 "\n"
18649 "SYNOPSIS:\n"
18650 "\n"
18651 "plmtex3(side, disp, pos, just, text)\n"
18652 "\n"
18653 "ARGUMENTS:\n"
18654 "\n"
18655 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18656 " the side of the viewport along which the text is to be written.\n"
18657 " The string should contain one or more of the following characters:\n"
18658 " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18659 " only label the X axis, not both the X and Y axes. x: Label the X\n"
18660 " axis.\n"
18661 " y: Label the Y axis.\n"
18662 " z: Label the Z axis.\n"
18663 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18664 " For X it is the axis that starts at y-min. For Y it is the\n"
18665 " axis that starts at x-min.\n"
18666 " s: Label the secondary axis.\n"
18667 " v: Draw the text perpendicular to the axis.\n"
18668 "\n"
18669 "\n"
18670 " disp (PLFLT, input) : Position of the reference point of string,\n"
18671 " measured outwards from the specified viewport edge in units of the\n"
18672 " current character height. Use negative disp to write within the\n"
18673 " viewport.\n"
18674 "\n"
18675 " pos (PLFLT, input) : Position of the reference point of string\n"
18676 " along the specified edge, expressed as a fraction of the length of\n"
18677 " the edge.\n"
18678 "\n"
18679 " just (PLFLT, input) : Specifies the position of the string relative\n"
18680 " to its reference point. If just=0. , the reference point is at\n"
18681 " the left and if just=1. , it is at the right of the string. Other\n"
18682 " values of just give intermediate justifications.\n"
18683 "\n"
18684 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18685 " written out.\n"
18686 "\n"
18687 ""},
18688 { "plot3d", _wrap_plot3d, METH_VARARGS, "\n"
18689 "Plot 3-d surface plot\n"
18690 "\n"
18691 "DESCRIPTION:\n"
18692 "\n"
18693 " Plots a three-dimensional surface plot within the environment set up\n"
18694 " by plw3d. The surface is defined by the matrix z[\n"
18695 " nx][\n"
18696 " ny] , the point z[i][j] being the value of the function at (\n"
18697 " x[i],\n"
18698 " y[j]). Note that the points in vectors x and y do not need to be\n"
18699 " equally spaced, but must be stored in ascending order. The parameter\n"
18700 " opt controls the way in which the surface is displayed. For further\n"
18701 " details see the PLplot documentation. The only difference between\n"
18702 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18703 " while plot3d only draws the surface as viewed from the top.\n"
18704 "\n"
18705 " Redacted form: plot3d(x, y, z, opt, side)\n"
18706 "\n"
18707 " This function is used in examples 11 and 21.\n"
18708 "\n"
18709 "\n"
18710 "\n"
18711 "SYNOPSIS:\n"
18712 "\n"
18713 "plot3d(x, y, z, nx, ny, opt, side)\n"
18714 "\n"
18715 "ARGUMENTS:\n"
18716 "\n"
18717 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18718 " which the function is evaluated.\n"
18719 "\n"
18720 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18721 " which the function is evaluated.\n"
18722 "\n"
18723 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18724 " plot. Should have dimensions of\n"
18725 " nx by\n"
18726 " ny.\n"
18727 "\n"
18728 " nx (PLINT, input) : Number of x values at which function is\n"
18729 " evaluated.\n"
18730 "\n"
18731 " ny (PLINT, input) : Number of y values at which function is\n"
18732 " evaluated.\n"
18733 "\n"
18734 " opt (PLINT, input) : Determines the way in which the surface is\n"
18735 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18736 " function of x for each value of y[j] .\n"
18737 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18738 " for each value of x[i] .\n"
18739 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18740 " at which function is defined.\n"
18741 "\n"
18742 "\n"
18743 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18744 " should be draw on the figure. If side is true sides are drawn,\n"
18745 " otherwise no sides are drawn.\n"
18746 "\n"
18747 ""},
18748 { "plot3dc", _wrap_plot3dc, METH_VARARGS, "\n"
18749 "Magnitude colored plot surface with contour\n"
18750 "\n"
18751 "DESCRIPTION:\n"
18752 "\n"
18753 " Aside from dropping the\n"
18754 " side functionality this is a more powerful form of plot3d: the surface\n"
18755 " mesh can be colored accordingly to the current z value being plotted,\n"
18756 " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18757 " drawn between the plotted function border and the base XY plane. The\n"
18758 " arguments are identical to those of plmeshc. The only difference\n"
18759 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18760 " the surface, while plot3dc only draws the surface as viewed from the\n"
18761 " top.\n"
18762 "\n"
18763 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18764 "\n"
18765 "\n"
18766 " This function is used in example 21.\n"
18767 "\n"
18768 "\n"
18769 "\n"
18770 "SYNOPSIS:\n"
18771 "\n"
18772 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18773 "\n"
18774 "ARGUMENTS:\n"
18775 "\n"
18776 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18777 " which the function is evaluated.\n"
18778 "\n"
18779 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18780 " which the function is evaluated.\n"
18781 "\n"
18782 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18783 " plot. Should have dimensions of\n"
18784 " nx by\n"
18785 " ny.\n"
18786 "\n"
18787 " nx (PLINT, input) : Number of x values at which function is\n"
18788 " evaluated.\n"
18789 "\n"
18790 " ny (PLINT, input) : Number of y values at which function is\n"
18791 " evaluated.\n"
18792 "\n"
18793 " opt (PLINT, input) : Determines the way in which the surface is\n"
18794 " represented. To specify more than one option just add the options,\n"
18795 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18796 " showing z as a function of x for each value of y[j] .\n"
18797 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18798 " for each value of x[i] .\n"
18799 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18800 " at which function is defined.\n"
18801 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18802 " the z value being plotted. The color is used from the current\n"
18803 " cmap1.\n"
18804 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18805 " using parameters\n"
18806 " nlevel and\n"
18807 " clevel.\n"
18808 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18809 " the borders of the plotted function.\n"
18810 "\n"
18811 "\n"
18812 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18813 " levels.\n"
18814 "\n"
18815 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18816 "\n"
18817 ""},
18818 { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, "\n"
18819 "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18820 "\n"
18821 "DESCRIPTION:\n"
18822 "\n"
18823 " When the implementation is completed this variant of plot3dc (see that\n"
18824 " function's documentation for more details) should be suitable for the\n"
18825 " case where the area of the x, y coordinate grid where z is defined can\n"
18826 " be non-rectangular. The implementation is incomplete so the last 4\n"
18827 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18828 " indexymax; are currently ignored and the functionality is otherwise\n"
18829 " identical to that of plot3dc.\n"
18830 "\n"
18831 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18832 " indexymin, indexymax)\n"
18833 "\n"
18834 "\n"
18835 " This function is not used in any example.\n"
18836 "\n"
18837 "\n"
18838 "\n"
18839 "SYNOPSIS:\n"
18840 "\n"
18841 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18842 "\n"
18843 "ARGUMENTS:\n"
18844 "\n"
18845 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18846 " which the function is evaluated.\n"
18847 "\n"
18848 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18849 " which the function is evaluated.\n"
18850 "\n"
18851 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18852 " plot. Should have dimensions of\n"
18853 " nx by\n"
18854 " ny.\n"
18855 "\n"
18856 " nx (PLINT, input) : Number of x values at which the function is\n"
18857 " evaluated.\n"
18858 "\n"
18859 " ny (PLINT, input) : Number of y values at which the function is\n"
18860 " evaluated.\n"
18861 "\n"
18862 " opt (PLINT, input) : Determines the way in which the surface is\n"
18863 " represented. To specify more than one option just add the options,\n"
18864 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18865 " showing z as a function of x for each value of y[j] .\n"
18866 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18867 " for each value of x[i] .\n"
18868 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18869 " at which function is defined.\n"
18870 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18871 " the z value being plotted. The color is used from the current\n"
18872 " cmap1.\n"
18873 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18874 " using parameters\n"
18875 " nlevel and\n"
18876 " clevel.\n"
18877 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18878 " the borders of the plotted function.\n"
18879 "\n"
18880 "\n"
18881 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18882 " levels.\n"
18883 "\n"
18884 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18885 "\n"
18886 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18887 " corresponds to the first x index where z is defined.\n"
18888 "\n"
18889 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18890 " which corresponds (by convention) to one more than the last x\n"
18891 " index value where z is defined.\n"
18892 "\n"
18893 " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18894 " values which all must be ≥ 0. These values are the first y index\n"
18895 " where z is defined for a particular x index in the range from\n"
18896 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18897 " indexxmax.\n"
18898 "\n"
18899 " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18900 " values which all must be ≤ ny. These values correspond (by\n"
18901 " convention) to one more than the last y index where z is defined\n"
18902 " for a particular x index in the range from indexxmin to indexxmax\n"
18903 " - 1. The dimension of indexymax is indexxmax.\n"
18904 "\n"
18905 ""},
18906 { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, "\n"
18907 "Plot shaded 3-d surface plot\n"
18908 "\n"
18909 "DESCRIPTION:\n"
18910 "\n"
18911 " Plots a three-dimensional shaded surface plot within the environment\n"
18912 " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18913 " z[\n"
18914 " nx][\n"
18915 " ny], the point z[i][j] being the value of the function at (\n"
18916 " x[i],\n"
18917 " y[j]). Note that the points in vectors x and y do not need to be\n"
18918 " equally spaced, but must be stored in ascending order. For further\n"
18919 " details see the PLplot documentation.\n"
18920 "\n"
18921 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18922 "\n"
18923 " This function is not used in any examples.\n"
18924 "\n"
18925 "\n"
18926 "\n"
18927 "SYNOPSIS:\n"
18928 "\n"
18929 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18930 "\n"
18931 "ARGUMENTS:\n"
18932 "\n"
18933 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18934 " which the function is evaluated.\n"
18935 "\n"
18936 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18937 " which the function is evaluated.\n"
18938 "\n"
18939 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18940 " plot. Should have dimensions of\n"
18941 " nx by\n"
18942 " ny.\n"
18943 "\n"
18944 " nx (PLINT, input) : Number of x values at which function is\n"
18945 " evaluated.\n"
18946 "\n"
18947 " ny (PLINT, input) : Number of y values at which function is\n"
18948 " evaluated.\n"
18949 "\n"
18950 " opt (PLINT, input) : Determines the way in which the surface is\n"
18951 " represented. To specify more than one option just add the options,\n"
18952 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18953 " connecting points at which function is defined.\n"
18954 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18955 " using parameters\n"
18956 " nlevel and\n"
18957 " clevel.\n"
18958 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18959 " using parameters\n"
18960 " nlevel and\n"
18961 " clevel.\n"
18962 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18963 " the borders of the plotted function.\n"
18964 " opt=MAG_COLOR : the surface is colored according to the value\n"
18965 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18966 " according to the intensity of the reflected light in the\n"
18967 " surface from a light source whose position is set using\n"
18968 " pllightsource.\n"
18969 "\n"
18970 "\n"
18971 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18972 " levels.\n"
18973 "\n"
18974 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18975 "\n"
18976 ""},
18977 { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, "\n"
18978 "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18979 "\n"
18980 "DESCRIPTION:\n"
18981 "\n"
18982 " This variant of plsurf3d (see that function's documentation for more\n"
18983 " details) should be suitable for the case where the area of the x, y\n"
18984 " coordinate grid where z is defined can be non-rectangular. The limits\n"
18985 " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18986 " indexymin, and indexymax.\n"
18987 "\n"
18988 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18989 " indexymax)\n"
18990 "\n"
18991 " This function is used in example 8.\n"
18992 "\n"
18993 "\n"
18994 "\n"
18995 "SYNOPSIS:\n"
18996 "\n"
18997 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18998 "\n"
18999 "ARGUMENTS:\n"
19000 "\n"
19001 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
19002 " which the function is evaluated.\n"
19003 "\n"
19004 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
19005 " which the function is evaluated.\n"
19006 "\n"
19007 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
19008 " plot. Should have dimensions of\n"
19009 " nx by\n"
19010 " ny.\n"
19011 "\n"
19012 " nx (PLINT, input) : Number of x values at which function is\n"
19013 " evaluated.\n"
19014 "\n"
19015 " ny (PLINT, input) : Number of y values at which function is\n"
19016 " evaluated.\n"
19017 "\n"
19018 " opt (PLINT, input) : Determines the way in which the surface is\n"
19019 " represented. To specify more than one option just add the options,\n"
19020 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
19021 " connecting points at which function is defined.\n"
19022 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
19023 " using parameters\n"
19024 " nlevel and\n"
19025 " clevel.\n"
19026 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
19027 " using parameters\n"
19028 " nlevel and\n"
19029 " clevel.\n"
19030 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
19031 " the borders of the plotted function.\n"
19032 " opt=MAG_COLOR : the surface is colored according to the value\n"
19033 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
19034 " according to the intensity of the reflected light in the\n"
19035 " surface from a light source whose position is set using\n"
19036 " pllightsource.\n"
19037 "\n"
19038 "\n"
19039 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
19040 " levels.\n"
19041 "\n"
19042 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
19043 "\n"
19044 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
19045 " corresponds to the first x index where z is defined.\n"
19046 "\n"
19047 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
19048 " which corresponds (by convention) to one more than the last x\n"
19049 " index value where z is defined.\n"
19050 "\n"
19051 " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
19052 " values which all must be ≥ 0. These values are the first y index\n"
19053 " where z is defined for a particular x index in the range from\n"
19054 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
19055 " indexxmax.\n"
19056 "\n"
19057 " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
19058 " values which all must be ≤ ny. These values correspond (by\n"
19059 " convention) to one more than the last y index where z is defined\n"
19060 " for a particular x index in the range from indexxmin to indexxmax\n"
19061 " - 1. The dimension of indexymax is indexxmax.\n"
19062 "\n"
19063 ""},
19064 { "plparseopts", _wrap_plparseopts, METH_VARARGS, "\n"
19065 "Parse command-line arguments\n"
19066 "\n"
19067 "DESCRIPTION:\n"
19068 "\n"
19069 " Parse command-line arguments.\n"
19070 "\n"
19071 " plparseopts removes all recognized flags (decreasing argc\n"
19072 " accordingly), so that invalid input may be readily detected. It can\n"
19073 " also be used to process user command line flags. The user can merge\n"
19074 " an option table of type PLOptionTable into the internal option table\n"
19075 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
19076 " the external table(s) be parsed by calling plClearOpts before\n"
19077 " plMergeOpts.\n"
19078 "\n"
19079 " The default action taken by plparseopts is as follows:\n"
19080 " Returns with an error if an unrecognized option or badly formed\n"
19081 " option-value pair are encountered.\n"
19082 " Returns immediately (return code 0) when the first non-option command\n"
19083 " line argument is found.\n"
19084 " Returns with the return code of the option handler, if one was called.\n"
19085 "\n"
19086 " Deletes command line arguments from argv list as they are found, and\n"
19087 " decrements argc accordingly.\n"
19088 " Does not show \"invisible\" options in usage or help messages.\n"
19089 " Assumes the program name is contained in argv[0].\n"
19090 "\n"
19091 " These behaviors may be controlled through the\n"
19092 " mode argument.\n"
19093 "\n"
19094 " Redacted form: General: plparseopts(argv, mode)\n"
19095 "\n"
19096 "\n"
19097 " This function is used in all of the examples.\n"
19098 "\n"
19099 "\n"
19100 "\n"
19101 "SYNOPSIS:\n"
19102 "\n"
19103 "PLINT plparseopts(p_argc, argv, mode)\n"
19104 "\n"
19105 "ARGUMENTS:\n"
19106 "\n"
19107 " p_argc (int *, input/output) : Number of arguments.\n"
19108 "\n"
19109 " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
19110 " strings containing *p_argc command-line arguments.\n"
19111 "\n"
19112 " mode (PLINT, input) : Parsing mode with the following\n"
19113 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
19114 " and all error messages enabled, including program exit when an\n"
19115 " error occurs. Anything on the command line that isn't recognized\n"
19116 " as a valid option or option argument is flagged as an error.\n"
19117 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
19118 " of errors.\n"
19119 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
19120 " arguments.\n"
19121 " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
19122 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
19123 " pointer to the program name.\n"
19124 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
19125 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
19126 " unrecognized arguments.\n"
19127 "\n"
19128 ""},
19129 { "plpat", _wrap_plpat, METH_VARARGS, "\n"
19130 "Set area line fill pattern\n"
19131 "\n"
19132 "DESCRIPTION:\n"
19133 "\n"
19134 " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
19135 " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
19136 " inclinations and spacings. The arguments to this routine are the\n"
19137 " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
19138 " elements) specifying the inclinations in tenths of a degree and the\n"
19139 " spacing in micrometers. (See also plpsty)\n"
19140 "\n"
19141 " Redacted form: General: plpat(inc, del)\n"
19142 "\n"
19143 "\n"
19144 " This function is used in example 15.\n"
19145 "\n"
19146 "\n"
19147 "\n"
19148 "SYNOPSIS:\n"
19149 "\n"
19150 "plpat(nlin, inc, del)\n"
19151 "\n"
19152 "ARGUMENTS:\n"
19153 "\n"
19154 " nlin (PLINT, input) : Number of sets of lines making up the\n"
19155 " pattern, either 1 or 2.\n"
19156 "\n"
19157 " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19158 " inclination in tenths of a degree. (Should be between -900 and\n"
19159 " 900).\n"
19160 "\n"
19161 " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19162 " spacing in micrometers between the lines making up the pattern.\n"
19163 "\n"
19164 ""},
19165 { "plpath", _wrap_plpath, METH_VARARGS, "\n"
19166 "Draw a line between two points, accounting for coordinate transforms\n"
19167 "\n"
19168 "DESCRIPTION:\n"
19169 "\n"
19170 " Joins the point (\n"
19171 " x1,\n"
19172 " y1) to (\n"
19173 " x2,\n"
19174 " y2) . If a global coordinate transform is defined then the line is\n"
19175 " broken in to n segments to approximate the path. If no transform is\n"
19176 " defined then this simply acts like a call to pljoin.\n"
19177 "\n"
19178 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
19179 "\n"
19180 " This function is used in example 22.\n"
19181 "\n"
19182 "\n"
19183 "\n"
19184 "SYNOPSIS:\n"
19185 "\n"
19186 "plpath(n, x1, y1, x2, y2)\n"
19187 "\n"
19188 "ARGUMENTS:\n"
19189 "\n"
19190 " n (PLINT, input) : number of points to use to approximate the path.\n"
19191 "\n"
19192 " x1 (PLFLT, input) : x coordinate of first point.\n"
19193 "\n"
19194 " y1 (PLFLT, input) : y coordinate of first point.\n"
19195 "\n"
19196 " x2 (PLFLT, input) : x coordinate of second point.\n"
19197 "\n"
19198 " y2 (PLFLT, input) : y coordinate of second point.\n"
19199 "\n"
19200 ""},
19201 { "plpoin", _wrap_plpoin, METH_VARARGS, "\n"
19202 "Plot a glyph at the specified points\n"
19203 "\n"
19204 "DESCRIPTION:\n"
19205 "\n"
19206 " Plot a glyph at the specified points. (This function is largely\n"
19207 " superseded by plstring which gives access to many[!] more glyphs.)\n"
19208 " code=-1 means try to just draw a point. Right now it's just a move\n"
19209 " and a draw at the same place. Not ideal, since a sufficiently\n"
19210 " intelligent output device may optimize it away, or there may be faster\n"
19211 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19212 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19213 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19214 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19215 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19216 "\n"
19217 " Redacted form: plpoin(x, y, code)\n"
19218 "\n"
19219 " This function is used in examples 1, 6, 14, and 29.\n"
19220 "\n"
19221 "\n"
19222 "\n"
19223 "SYNOPSIS:\n"
19224 "\n"
19225 "plpoin(n, x, y, code)\n"
19226 "\n"
19227 "ARGUMENTS:\n"
19228 "\n"
19229 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19230 "\n"
19231 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19232 " points.\n"
19233 "\n"
19234 " y (PLFLT_VECTOR, input) : A vector containing the y 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 { "plpoin3", _wrap_plpoin3, METH_VARARGS, "\n"
19243 "Plot a glyph at the specified 3D points\n"
19244 "\n"
19245 "DESCRIPTION:\n"
19246 "\n"
19247 " Plot a glyph at the specified 3D points. (This function is largely\n"
19248 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
19249 " Set up the call to this function similar to what is done for plline3.\n"
19250 " code=-1 means try to just draw a point. Right now it's just a move\n"
19251 " and a draw at the same place. Not ideal, since a sufficiently\n"
19252 " intelligent output device may optimize it away, or there may be faster\n"
19253 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19254 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19255 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19256 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19257 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19258 "\n"
19259 " Redacted form: plpoin3(x, y, z, code)\n"
19260 "\n"
19261 " This function is not used in any example.\n"
19262 "\n"
19263 "\n"
19264 "\n"
19265 "SYNOPSIS:\n"
19266 "\n"
19267 "plpoin3(n, x, y, z, code)\n"
19268 "\n"
19269 "ARGUMENTS:\n"
19270 "\n"
19271 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19272 "\n"
19273 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19274 " points.\n"
19275 "\n"
19276 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19277 " points.\n"
19278 "\n"
19279 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
19280 " points.\n"
19281 "\n"
19282 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19283 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19284 " each of the n points.\n"
19285 "\n"
19286 ""},
19287 { "plpoly3", _wrap_plpoly3, METH_VARARGS, "\n"
19288 "Draw a polygon in 3 space\n"
19289 "\n"
19290 "DESCRIPTION:\n"
19291 "\n"
19292 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19293 " like plline3, but differs from that function in that plpoly3 attempts\n"
19294 " to determine if the polygon is viewable depending on the order of the\n"
19295 " points within the vector and the value of ifcc. If the back of\n"
19296 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19297 " you want, then use plline3 instead.\n"
19298 "\n"
19299 " The points are assumed to be in a plane, and the directionality of the\n"
19300 " plane is determined from the first three points. Additional points do\n"
19301 " not have to lie on the plane defined by the first three, but if they\n"
19302 " do not, then the determination of visibility obviously can't be 100%\n"
19303 " accurate... So if you're 3 space polygons are too far from planar,\n"
19304 " consider breaking them into smaller polygons. 3 points define a plane\n"
19305 " :-).\n"
19306 "\n"
19307 " Bugs: If one of the first two segments is of zero length, or if they\n"
19308 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19309 " being correct. Avoid such situations :-). See x18c.c for an example\n"
19310 " of this problem. (Search for 20.1).\n"
19311 "\n"
19312 " Redacted form: plpoly3(x, y, z, code)\n"
19313 "\n"
19314 " This function is used in example 18.\n"
19315 "\n"
19316 "\n"
19317 "\n"
19318 "SYNOPSIS:\n"
19319 "\n"
19320 "plpoly3(n, x, y, z, draw, ifcc)\n"
19321 "\n"
19322 "ARGUMENTS:\n"
19323 "\n"
19324 " n (PLINT, input) : Number of points defining line.\n"
19325 "\n"
19326 " x (PLFLT_VECTOR, input) : A vector containing\n"
19327 " n x coordinates of points.\n"
19328 "\n"
19329 " y (PLFLT_VECTOR, input) : A vector containing\n"
19330 " n y coordinates of points.\n"
19331 "\n"
19332 " z (PLFLT_VECTOR, input) : A vector containing\n"
19333 " n z coordinates of points.\n"
19334 "\n"
19335 " draw (PLBOOL_VECTOR, input) : A vector containing\n"
19336 " n-1 Boolean values which control drawing the segments of the polygon.\n"
19337 " If draw[i] is true, then the polygon segment from index [i] to\n"
19338 " [i+1] is drawn, otherwise, not.\n"
19339 "\n"
19340 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19341 " polygon is determined by assuming the points are laid out in a\n"
19342 " counter-clockwise order. Otherwise, the directionality of the\n"
19343 " polygon is determined by assuming the points are laid out in a\n"
19344 " clockwise order.\n"
19345 "\n"
19346 ""},
19347 { "plprec", _wrap_plprec, METH_VARARGS, "\n"
19348 "Set precision in numeric labels\n"
19349 "\n"
19350 "DESCRIPTION:\n"
19351 "\n"
19352 " Sets the number of places after the decimal point in numeric labels.\n"
19353 "\n"
19354 " Redacted form: plprec(setp, prec)\n"
19355 "\n"
19356 " This function is used in example 29.\n"
19357 "\n"
19358 "\n"
19359 "\n"
19360 "SYNOPSIS:\n"
19361 "\n"
19362 "plprec(setp, prec)\n"
19363 "\n"
19364 "ARGUMENTS:\n"
19365 "\n"
19366 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19367 " automatically determines the number of places to use after the\n"
19368 " decimal point in numeric labels (like those used to label axes).\n"
19369 " If setp is 1 then prec sets the number of places.\n"
19370 "\n"
19371 " prec (PLINT, input) : The number of characters to draw after the\n"
19372 " decimal point in numeric labels.\n"
19373 "\n"
19374 ""},
19375 { "plpsty", _wrap_plpsty, METH_O, "\n"
19376 "Select area fill pattern\n"
19377 "\n"
19378 "DESCRIPTION:\n"
19379 "\n"
19380 " If\n"
19381 " patt is zero or less use either a hardware solid fill if the drivers\n"
19382 " have that capability (virtually all do) or fall back to a software\n"
19383 " emulation of a solid fill using the eighth area line fill pattern. If\n"
19384 " 0 <\n"
19385 " patt <= 8, then select one of eight predefined area line fill patterns\n"
19386 " to use (see plpat if you desire other patterns).\n"
19387 "\n"
19388 " Redacted form: plpsty(patt)\n"
19389 "\n"
19390 " This function is used in examples 12, 13, 15, 16, and 25.\n"
19391 "\n"
19392 "\n"
19393 "\n"
19394 "SYNOPSIS:\n"
19395 "\n"
19396 "plpsty(patt)\n"
19397 "\n"
19398 "ARGUMENTS:\n"
19399 "\n"
19400 " patt (PLINT, input) : The desired pattern index. If\n"
19401 " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
19402 " above) used. For\n"
19403 " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
19404 " line fill capability itself (most deliberately do not so that line\n"
19405 " fill patterns look identical for those drivers), the patterns\n"
19406 " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
19407 " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
19408 " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
19409 " (8) lines at both 45 degrees and -45 degrees.\n"
19410 "\n"
19411 ""},
19412 { "plptex", _wrap_plptex, METH_VARARGS, "\n"
19413 "Write text inside the viewport\n"
19414 "\n"
19415 "DESCRIPTION:\n"
19416 "\n"
19417 " Writes text at a specified position and inclination within the\n"
19418 " viewport. Text is clipped at the viewport boundaries. The reference\n"
19419 " point of a string lies along a line passing through the string at half\n"
19420 " the height of a capital letter. The position of the reference point\n"
19421 " along this line is determined by just, the reference point is placed\n"
19422 " at world coordinates (\n"
19423 " x,\n"
19424 " y) within the viewport. The inclination of the string is specified\n"
19425 " in terms of differences of world coordinates making it easy to write\n"
19426 " text parallel to a line in a graph.\n"
19427 "\n"
19428 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19429 "\n"
19430 " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
19431 "\n"
19432 "\n"
19433 "\n"
19434 "SYNOPSIS:\n"
19435 "\n"
19436 "plptex(x, y, dx, dy, just, text)\n"
19437 "\n"
19438 "ARGUMENTS:\n"
19439 "\n"
19440 " x (PLFLT, input) : x coordinate of reference point of string.\n"
19441 "\n"
19442 " y (PLFLT, input) : y coordinate of reference point of string.\n"
19443 "\n"
19444 " dx (PLFLT, input) : Together with dy, this specifies the\n"
19445 " inclination of the string. The baseline of the string is parallel\n"
19446 " to a line joining (\n"
19447 " x,\n"
19448 " y) to (\n"
19449 " x+\n"
19450 " dx,\n"
19451 " y+\n"
19452 " dy) .\n"
19453 "\n"
19454 " dy (PLFLT, input) : Together with dx, this specifies the\n"
19455 " inclination of the string.\n"
19456 "\n"
19457 " just (PLFLT, input) : Specifies the position of the string relative\n"
19458 " to its reference point. If just=0. , the reference point is at\n"
19459 " the left and if just=1. , it is at the right of the string. Other\n"
19460 " values of just give intermediate justifications.\n"
19461 "\n"
19462 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19463 " written out.\n"
19464 "\n"
19465 ""},
19466 { "plptex3", _wrap_plptex3, METH_VARARGS, "\n"
19467 "Write text inside the viewport of a 3D plot\n"
19468 "\n"
19469 "DESCRIPTION:\n"
19470 "\n"
19471 " Writes text at a specified position and inclination and with a\n"
19472 " specified shear within the viewport. Text is clipped at the viewport\n"
19473 " boundaries. The reference point of a string lies along a line passing\n"
19474 " through the string at half the height of a capital letter. The\n"
19475 " position of the reference point along this line is determined by just,\n"
19476 " and the reference point is placed at world coordinates (\n"
19477 " wx,\n"
19478 " wy,\n"
19479 " wz) within the viewport. The inclination and shear of the string is\n"
19480 " specified in terms of differences of world coordinates making it easy\n"
19481 " to write text parallel to a line in a graph.\n"
19482 "\n"
19483 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19484 "\n"
19485 " This function is used in example 28.\n"
19486 "\n"
19487 "\n"
19488 "\n"
19489 "SYNOPSIS:\n"
19490 "\n"
19491 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19492 "\n"
19493 "ARGUMENTS:\n"
19494 "\n"
19495 " wx (PLFLT, input) : x world coordinate of reference point of\n"
19496 " string.\n"
19497 "\n"
19498 " wy (PLFLT, input) : y world coordinate of reference point of\n"
19499 " string.\n"
19500 "\n"
19501 " wz (PLFLT, input) : z world coordinate of reference point of\n"
19502 " string.\n"
19503 "\n"
19504 " dx (PLFLT, input) : Together with dy and\n"
19505 " dz , this specifies the inclination of the string. The baseline of\n"
19506 " the string is parallel to a line joining (\n"
19507 " x,\n"
19508 " y,\n"
19509 " z) to (\n"
19510 " x+\n"
19511 " dx,\n"
19512 " y+\n"
19513 " dy,\n"
19514 " z+\n"
19515 " dz) .\n"
19516 "\n"
19517 " dy (PLFLT, input) : Together with dx and\n"
19518 " dz, this specifies the inclination of the string.\n"
19519 "\n"
19520 " dz (PLFLT, input) : Together with dx and\n"
19521 " dy, this specifies the inclination of the string.\n"
19522 "\n"
19523 " sx (PLFLT, input) : Together with sy and\n"
19524 " sz , this specifies the shear of the string. The string is sheared so\n"
19525 " that the characters are vertically parallel to a line joining (\n"
19526 " x,\n"
19527 " y,\n"
19528 " z) to (\n"
19529 " x+\n"
19530 " sx,\n"
19531 " y+\n"
19532 " sy,\n"
19533 " z+\n"
19534 " sz) . If sx =\n"
19535 " sy =\n"
19536 " sz = 0.) then the text is not sheared.\n"
19537 "\n"
19538 " sy (PLFLT, input) : Together with sx and\n"
19539 " sz, this specifies shear of the string.\n"
19540 "\n"
19541 " sz (PLFLT, input) : Together with sx and\n"
19542 " sy, this specifies shear of the string.\n"
19543 "\n"
19544 " just (PLFLT, input) : Specifies the position of the string relative\n"
19545 " to its reference point. If just=0. , the reference point is at\n"
19546 " the left and if just=1. , it is at the right of the string. Other\n"
19547 " values of just give intermediate justifications.\n"
19548 "\n"
19549 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19550 " written out.\n"
19551 "\n"
19552 ""},
19553 { "plrandd", _wrap_plrandd, METH_NOARGS, "\n"
19554 "Random number generator returning a real random number in the range [0,1]\n"
19555 "\n"
19556 "DESCRIPTION:\n"
19557 "\n"
19558 " Random number generator returning a real random number in the range\n"
19559 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19560 " / compilers provide their own random number generator, and so this is\n"
19561 " provided purely for convenience and to give a consistent random number\n"
19562 " generator across all languages supported by PLplot. This is\n"
19563 " particularly useful for comparing results from the test suite of\n"
19564 " examples.\n"
19565 "\n"
19566 " Redacted form: plrandd()\n"
19567 "\n"
19568 " This function is used in examples 17 and 21.\n"
19569 "\n"
19570 "\n"
19571 "\n"
19572 "SYNOPSIS:\n"
19573 "\n"
19574 "plrandd()\n"
19575 "\n"
19576 ""},
19577 { "plreplot", _wrap_plreplot, METH_NOARGS, "\n"
19578 "Replays contents of plot buffer to current device/file\n"
19579 "\n"
19580 "DESCRIPTION:\n"
19581 "\n"
19582 " Replays contents of plot buffer to current device/file.\n"
19583 "\n"
19584 " Redacted form: plreplot()\n"
19585 "\n"
19586 " This function is used in example 1,20.\n"
19587 "\n"
19588 "\n"
19589 "\n"
19590 "SYNOPSIS:\n"
19591 "\n"
19592 "plreplot()\n"
19593 "\n"
19594 ""},
19595 { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, "\n"
19596 "Convert RGB color to HLS\n"
19597 "\n"
19598 "DESCRIPTION:\n"
19599 "\n"
19600 " Convert RGB color coordinates to HLS\n"
19601 "\n"
19602 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19603 "\n"
19604 "\n"
19605 " This function is used in example 2.\n"
19606 "\n"
19607 "\n"
19608 "\n"
19609 "SYNOPSIS:\n"
19610 "\n"
19611 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19612 "\n"
19613 "ARGUMENTS:\n"
19614 "\n"
19615 " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19616 "\n"
19617 " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19618 "\n"
19619 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19620 "\n"
19621 " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19622 " degrees (0.0-360.0) on the color cylinder.\n"
19623 "\n"
19624 " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19625 " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19626 " cylinder.\n"
19627 "\n"
19628 " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19629 " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19630 " cylinder.\n"
19631 "\n"
19632 ""},
19633 { "plschr", _wrap_plschr, METH_VARARGS, "\n"
19634 "Set character size\n"
19635 "\n"
19636 "DESCRIPTION:\n"
19637 "\n"
19638 " This sets up the size of all subsequent characters drawn. The actual\n"
19639 " height of a character is the product of the default character size and\n"
19640 " a scaling factor.\n"
19641 "\n"
19642 " Redacted form: plschr(def, scale)\n"
19643 "\n"
19644 " This function is used in examples 2, 13, 23, and 24.\n"
19645 "\n"
19646 "\n"
19647 "\n"
19648 "SYNOPSIS:\n"
19649 "\n"
19650 "plschr(def, scale)\n"
19651 "\n"
19652 "ARGUMENTS:\n"
19653 "\n"
19654 " def (PLFLT, input) : The default height of a character in\n"
19655 " millimeters, should be set to zero if the default height is to\n"
19656 " remain unchanged. For rasterized drivers the dx and dy values\n"
19657 " specified in plspage are used to convert from mm to pixels (note\n"
19658 " the different unit systems used). This dpi aware scaling is not\n"
19659 " implemented for all drivers yet.\n"
19660 "\n"
19661 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19662 " actual character height.\n"
19663 "\n"
19664 ""},
19665 { "plscmap0", _wrap_plscmap0, METH_VARARGS, "\n"
19666 "Set cmap0 colors by 8-bit RGB values\n"
19667 "\n"
19668 "DESCRIPTION:\n"
19669 "\n"
19670 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19671 " documentation). This sets the entire color map -- only as many colors\n"
19672 " as specified will be allocated.\n"
19673 "\n"
19674 " Redacted form: plscmap0(r, g, b)\n"
19675 "\n"
19676 " This function is used in examples 2 and 24.\n"
19677 "\n"
19678 "\n"
19679 "\n"
19680 "SYNOPSIS:\n"
19681 "\n"
19682 "plscmap0(r, g, b, ncol0)\n"
19683 "\n"
19684 "ARGUMENTS:\n"
19685 "\n"
19686 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19687 " integers (0-255) representing the degree of red in the color.\n"
19688 "\n"
19689 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19690 " integers (0-255) representing the degree of green in the color.\n"
19691 "\n"
19692 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19693 " integers (0-255) representing the degree of blue in the color.\n"
19694 "\n"
19695 " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19696 "\n"
19697 ""},
19698 { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, "\n"
19699 "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19700 "\n"
19701 "DESCRIPTION:\n"
19702 "\n"
19703 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19704 " and PLFLT alpha transparency value. This sets the entire color map --\n"
19705 " only as many colors as specified will be allocated.\n"
19706 "\n"
19707 " Redacted form: plscmap0a(r, g, b, alpha)\n"
19708 "\n"
19709 " This function is used in examples 30.\n"
19710 "\n"
19711 "\n"
19712 "\n"
19713 "SYNOPSIS:\n"
19714 "\n"
19715 "plscmap0a(r, g, b, alpha, ncol0)\n"
19716 "\n"
19717 "ARGUMENTS:\n"
19718 "\n"
19719 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19720 " integers (0-255) representing the degree of red in the color.\n"
19721 "\n"
19722 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19723 " integers (0-255) representing the degree of green in the color.\n"
19724 "\n"
19725 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19726 " integers (0-255) representing the degree of blue in the color.\n"
19727 "\n"
19728 " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19729 " representing the alpha transparency of the color.\n"
19730 "\n"
19731 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19732 " vectors.\n"
19733 "\n"
19734 ""},
19735 { "plscmap0n", _wrap_plscmap0n, METH_O, "\n"
19736 "Set number of colors in cmap0\n"
19737 "\n"
19738 "DESCRIPTION:\n"
19739 "\n"
19740 " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19741 " (or reallocate) cmap0, and fill with default values for those colors\n"
19742 " not previously allocated. The first 16 default colors are given in\n"
19743 " the plcol0 documentation. For larger indices the default color is\n"
19744 " red.\n"
19745 "\n"
19746 " The drivers are not guaranteed to support more than 16 colors.\n"
19747 "\n"
19748 " Redacted form: plscmap0n(ncol0)\n"
19749 "\n"
19750 " This function is used in examples 15, 16, and 24.\n"
19751 "\n"
19752 "\n"
19753 "\n"
19754 "SYNOPSIS:\n"
19755 "\n"
19756 "plscmap0n(ncol0)\n"
19757 "\n"
19758 "ARGUMENTS:\n"
19759 "\n"
19760 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19761 " the cmap0 palette. If this number is zero or less, then the value\n"
19762 " from the previous call to plscmap0n is used and if there is no\n"
19763 " previous call, then a default value is used.\n"
19764 "\n"
19765 ""},
19766 { "plscmap1", _wrap_plscmap1, METH_VARARGS, "\n"
19767 "Set opaque RGB cmap1 colors values\n"
19768 "\n"
19769 "DESCRIPTION:\n"
19770 "\n"
19771 " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19772 " vector values. This function also sets the number of cmap1 colors.\n"
19773 " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19774 " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19775 " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19776 " to\n"
19777 " ncol1-1. So in order for this continuous color model to work\n"
19778 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19779 " that these RGB vectors are continuous functions of their integer\n"
19780 " indices.\n"
19781 "\n"
19782 " Redacted form: plscmap1(r, g, b)\n"
19783 "\n"
19784 " This function is used in example 31.\n"
19785 "\n"
19786 "\n"
19787 "\n"
19788 "SYNOPSIS:\n"
19789 "\n"
19790 "plscmap1(r, g, b, ncol1)\n"
19791 "\n"
19792 "ARGUMENTS:\n"
19793 "\n"
19794 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19795 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19796 " color as a continuous function of the integer index of the vector.\n"
19797 "\n"
19798 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19799 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19800 " color as a continuous function of the integer index of the vector.\n"
19801 "\n"
19802 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19803 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19804 " color as a continuous function of the integer index of the vector.\n"
19805 "\n"
19806 " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19807 "\n"
19808 ""},
19809 { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, "\n"
19810 "Set semitransparent cmap1 RGBA colors.\n"
19811 "\n"
19812 "DESCRIPTION:\n"
19813 "\n"
19814 " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19815 " RGBA vector values. This function also sets the number of cmap1\n"
19816 " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19817 " floating-point index in the range from 0.0-1.0 which is linearly\n"
19818 " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19819 " vectors in the range from 0 to\n"
19820 " ncol1-1. So in order for this continuous color model to work\n"
19821 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19822 " that these RGBA vectors are continuous functions of their integer\n"
19823 " indices.\n"
19824 "\n"
19825 " Redacted form: plscmap1a(r, g, b, alpha)\n"
19826 "\n"
19827 " This function is used in example 31.\n"
19828 "\n"
19829 "\n"
19830 "\n"
19831 "SYNOPSIS:\n"
19832 "\n"
19833 "plscmap1a(r, g, b, alpha, ncol1)\n"
19834 "\n"
19835 "ARGUMENTS:\n"
19836 "\n"
19837 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19838 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19839 " color as a continuous function of the integer index of the vector.\n"
19840 "\n"
19841 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19842 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19843 " color as a continuous function of the integer index of the vector.\n"
19844 "\n"
19845 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19846 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19847 " color as a continuous function of the integer index of the vector.\n"
19848 "\n"
19849 " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19850 " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19851 " completely transparent and 1.0 corresponds to completely opaque)\n"
19852 " the alpha transparency of the color as a continuous function of\n"
19853 " the integer index of the vector.\n"
19854 "\n"
19855 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19856 " vectors.\n"
19857 "\n"
19858 ""},
19859 { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, "\n"
19860 "Set cmap1 colors using a piece-wise linear relationship\n"
19861 "\n"
19862 "DESCRIPTION:\n"
19863 "\n"
19864 " Set cmap1 colors using a piece-wise linear relationship between the\n"
19865 " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19866 " (see the PLplot documentation). May be called at any time.\n"
19867 "\n"
19868 " The idea here is to specify a number of control points that define the\n"
19869 " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19870 " these points, linear interpolation is used which gives a smooth\n"
19871 " variation of color with intensity index. Any number of control points\n"
19872 " may be specified, located at arbitrary positions, although typically 2\n"
19873 " - 4 are enough. Another way of stating this is that we are traversing\n"
19874 " a given number of lines through HLS or RGB space as we move through\n"
19875 " cmap1 intensity indices. The control points at the minimum and\n"
19876 " maximum position (0 and 1) must always be specified. By adding more\n"
19877 " control points you can get more variation. One good technique for\n"
19878 " plotting functions that vary about some expected average is to use an\n"
19879 " additional 2 control points in the center (position ~= 0.5) that are\n"
19880 " the same lightness as the background (typically white for paper\n"
19881 " output, black for crt), and same hue as the boundary control points.\n"
19882 " This allows the highs and lows to be very easily distinguished.\n"
19883 "\n"
19884 " Each control point must specify the cmap1 intensity index and the\n"
19885 " associated three coordinates in HLS or RGB space. The first point\n"
19886 " must correspond to position = 0, and the last to position = 1.\n"
19887 "\n"
19888 " If RGB colors are provided then the interpolation takes place in RGB\n"
19889 " space and is trivial. However if HLS colors are provided then, because\n"
19890 " of the circular nature of the color wheel for the hue coordinate, the\n"
19891 " interpolation could be performed in either direction around the color\n"
19892 " wheel. The default behaviour is for the hue to be linearly\n"
19893 " interpolated ignoring this circular property of hue. So for example,\n"
19894 " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19895 " green and cyan. If instead you wish to interpolate the other way\n"
19896 " around the color wheel you have two options. You may provide hues\n"
19897 " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19898 " for red the interpolation will proceed via magenta. Alternatively you\n"
19899 " can utilise the alt_hue_path variable to reverse the direction of\n"
19900 " interpolation if you need to provide hues within the [0-360) range.\n"
19901 "\n"
19902 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19903 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19904 " -120]falsegreen-yellow-red-magenta-blue[240\n"
19905 " 480]falseblue-magenta-red-yellow-green[120\n"
19906 " 240]truegreen-yellow-red-magenta-blue[240\n"
19907 " 120]trueblue-magenta-red-yellow-green\n"
19908 "\n"
19909 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19910 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19911 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19912 "\n"
19913 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19914 " alt_hue_path)\n"
19915 "\n"
19916 " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19917 "\n"
19918 "\n"
19919 "\n"
19920 "SYNOPSIS:\n"
19921 "\n"
19922 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19923 "\n"
19924 "ARGUMENTS:\n"
19925 "\n"
19926 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19927 "\n"
19928 " npts (PLINT, input) : number of control points\n"
19929 "\n"
19930 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19931 " intensity index (0.0-1.0) in ascending order for each control\n"
19932 " point.\n"
19933 "\n"
19934 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19935 " coordinate (H or R) for each control point.\n"
19936 "\n"
19937 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19938 " coordinate (L or G) for each control point.\n"
19939 "\n"
19940 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19941 " coordinate (S or B) for each control point.\n"
19942 "\n"
19943 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19944 " npts - 1 elements), each containing either true to use the reversed\n"
19945 " HLS interpolation or false to use the regular HLS interpolation.\n"
19946 " (alt_hue_path[i] refers to the interpolation interval between the\n"
19947 " i and i + 1 control points). This parameter is not used for RGB\n"
19948 " colors (\n"
19949 " itype = true).\n"
19950 "\n"
19951 ""},
19952 { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, "\n"
19953 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19954 "\n"
19955 "DESCRIPTION:\n"
19956 "\n"
19957 " This is a variant of plscmap1l that supports alpha channel\n"
19958 " transparency. It sets cmap1 colors using a piece-wise linear\n"
19959 " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19960 " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19961 " transparency value (0.0-1.0). It may be called at any time.\n"
19962 "\n"
19963 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19964 " alpha, alt_hue_path)\n"
19965 "\n"
19966 " This function is used in example 30.\n"
19967 "\n"
19968 "\n"
19969 "\n"
19970 "SYNOPSIS:\n"
19971 "\n"
19972 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19973 "\n"
19974 "ARGUMENTS:\n"
19975 "\n"
19976 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19977 "\n"
19978 " npts (PLINT, input) : number of control points.\n"
19979 "\n"
19980 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19981 " intensity index (0.0-1.0) in ascending order for each control\n"
19982 " point.\n"
19983 "\n"
19984 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19985 " coordinate (H or R) for each control point.\n"
19986 "\n"
19987 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19988 " coordinate (L or G) for each control point.\n"
19989 "\n"
19990 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19991 " coordinate (S or B) for each control point.\n"
19992 "\n"
19993 " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19994 " transparency value (0.0-1.0) for each control point.\n"
19995 "\n"
19996 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19997 " npts - 1 elements) containing the alternative interpolation method\n"
19998 " Boolean value for each control point interval. (alt_hue_path[i]\n"
19999 " refers to the interpolation interval between the i and i + 1\n"
20000 " control points).\n"
20001 "\n"
20002 ""},
20003 { "plscmap1n", _wrap_plscmap1n, METH_O, "\n"
20004 "Set number of colors in cmap1\n"
20005 "\n"
20006 "DESCRIPTION:\n"
20007 "\n"
20008 " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
20009 " values if this is the first allocation (see the PLplot documentation).\n"
20010 "\n"
20011 " Redacted form: plscmap1n(ncol1)\n"
20012 "\n"
20013 " This function is used in examples 8, 11, 20, and 21.\n"
20014 "\n"
20015 "\n"
20016 "\n"
20017 "SYNOPSIS:\n"
20018 "\n"
20019 "plscmap1n(ncol1)\n"
20020 "\n"
20021 "ARGUMENTS:\n"
20022 "\n"
20023 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
20024 " the cmap1 palette. If this number is zero or less, then the value\n"
20025 " from the previous call to plscmap1n is used and if there is no\n"
20026 " previous call, then a default value is used.\n"
20027 "\n"
20028 ""},
20029 { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, "\n"
20030 "Set the cmap1 argument range for continuous color plots\n"
20031 "\n"
20032 "DESCRIPTION:\n"
20033 "\n"
20034 " Set the cmap1 argument range for continuous color plots that\n"
20035 " corresponds to the range of data values. The maximum range\n"
20036 " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
20037 " the cmap1 argument range that is specified with this routine, the\n"
20038 " smaller the subset of the cmap1 color palette that is used to\n"
20039 " represent the continuous data being plotted. If\n"
20040 " min_color is greater than\n"
20041 " max_color or\n"
20042 " max_color is greater than 1.0 or\n"
20043 " min_color is less than 0.0 then no change is made to the cmap1\n"
20044 " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
20045 "\n"
20046 " Redacted form: plscmap1_range(min_color, max_color)\n"
20047 "\n"
20048 " This function is currently used in example 33.\n"
20049 "\n"
20050 "\n"
20051 "\n"
20052 "SYNOPSIS:\n"
20053 "\n"
20054 "plscmap1_range(min_color, max_color)\n"
20055 "\n"
20056 "ARGUMENTS:\n"
20057 "\n"
20058 " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
20059 " than 0.0, then 0.0 is used instead.\n"
20060 "\n"
20061 " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
20062 " than 1.0, then 1.0 is used instead.\n"
20063 "\n"
20064 ""},
20065 { "plgcmap1_range", _wrap_plgcmap1_range, METH_NOARGS, "\n"
20066 "Get the cmap1 argument range for continuous color plots\n"
20067 "\n"
20068 "DESCRIPTION:\n"
20069 "\n"
20070 " Get the cmap1 argument range for continuous color plots. (Use\n"
20071 " plscmap1_range to set the cmap1 argument range.)\n"
20072 "\n"
20073 " Redacted form: plgcmap1_range(min_color, max_color)\n"
20074 "\n"
20075 " This function is currently not used in any example.\n"
20076 "\n"
20077 "\n"
20078 "\n"
20079 "SYNOPSIS:\n"
20080 "\n"
20081 "plgcmap1_range(min_color, max_color)\n"
20082 "\n"
20083 "ARGUMENTS:\n"
20084 "\n"
20085 " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20086 " minimum cmap1 argument.\n"
20087 "\n"
20088 " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20089 " maximum cmap1 argument.\n"
20090 "\n"
20091 ""},
20092 { "plscol0", _wrap_plscol0, METH_VARARGS, "\n"
20093 "Set 8-bit RGB values for given cmap0 color index\n"
20094 "\n"
20095 "DESCRIPTION:\n"
20096 "\n"
20097 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
20098 " index. Overwrites the previous color value for the given index and,\n"
20099 " thus, does not result in any additional allocation of space for\n"
20100 " colors.\n"
20101 "\n"
20102 " Redacted form: plscol0(icol0, r, g, b)\n"
20103 "\n"
20104 " This function is used in any example 31.\n"
20105 "\n"
20106 "\n"
20107 "\n"
20108 "SYNOPSIS:\n"
20109 "\n"
20110 "plscol0(icol0, r, g, b)\n"
20111 "\n"
20112 "ARGUMENTS:\n"
20113 "\n"
20114 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20115 " number of colors (which is set by default, by plscmap0n, or even\n"
20116 " by plscmap0).\n"
20117 "\n"
20118 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20119 " degree of red in the color.\n"
20120 "\n"
20121 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20122 " degree of green in the color.\n"
20123 "\n"
20124 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20125 " degree of blue in the color.\n"
20126 "\n"
20127 ""},
20128 { "plscol0a", _wrap_plscol0a, METH_VARARGS, "\n"
20129 "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
20130 "\n"
20131 "DESCRIPTION:\n"
20132 "\n"
20133 " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
20134 " (see the PLplot documentation) index. Overwrites the previous color\n"
20135 " value for the given index and, thus, does not result in any additional\n"
20136 " allocation of space for colors.\n"
20137 "\n"
20138 " This function is used in example 30.\n"
20139 "\n"
20140 "\n"
20141 "\n"
20142 "SYNOPSIS:\n"
20143 "\n"
20144 "plscol0a(icol0, r, g, b, alpha)\n"
20145 "\n"
20146 "ARGUMENTS:\n"
20147 "\n"
20148 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20149 " number of colors (which is set by default, by plscmap0n, or even\n"
20150 " by plscmap0).\n"
20151 "\n"
20152 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20153 " degree of red in the color.\n"
20154 "\n"
20155 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20156 " degree of green in the color.\n"
20157 "\n"
20158 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20159 " degree of blue in the color.\n"
20160 "\n"
20161 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20162 " (0.0-1.0).\n"
20163 "\n"
20164 ""},
20165 { "plscolbg", _wrap_plscolbg, METH_VARARGS, "\n"
20166 "Set the background color by 8-bit RGB value\n"
20167 "\n"
20168 "DESCRIPTION:\n"
20169 "\n"
20170 " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
20171 " the PLplot documentation).\n"
20172 "\n"
20173 " Redacted form: plscolbg(r, g, b)\n"
20174 "\n"
20175 " This function is used in examples 15 and 31.\n"
20176 "\n"
20177 "\n"
20178 "\n"
20179 "SYNOPSIS:\n"
20180 "\n"
20181 "plscolbg(r, g, b)\n"
20182 "\n"
20183 "ARGUMENTS:\n"
20184 "\n"
20185 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20186 " degree of red in the color.\n"
20187 "\n"
20188 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20189 " degree of green in the color.\n"
20190 "\n"
20191 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20192 " degree of blue in the color.\n"
20193 "\n"
20194 ""},
20195 { "plscolbga", _wrap_plscolbga, METH_VARARGS, "\n"
20196 "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
20197 "\n"
20198 "DESCRIPTION:\n"
20199 "\n"
20200 " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
20201 " PLFLT alpha transparency value (see the PLplot documentation).\n"
20202 "\n"
20203 " This function is used in example 31.\n"
20204 "\n"
20205 "\n"
20206 "\n"
20207 "SYNOPSIS:\n"
20208 "\n"
20209 "plscolbga(r, g, b, alpha)\n"
20210 "\n"
20211 "ARGUMENTS:\n"
20212 "\n"
20213 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20214 " degree of red in the color.\n"
20215 "\n"
20216 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20217 " degree of green in the color.\n"
20218 "\n"
20219 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20220 " degree of blue in the color.\n"
20221 "\n"
20222 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20223 " (0.0-1.0).\n"
20224 "\n"
20225 ""},
20226 { "plscolor", _wrap_plscolor, METH_O, "\n"
20227 "Used to globally turn color output on/off\n"
20228 "\n"
20229 "DESCRIPTION:\n"
20230 "\n"
20231 " Used to globally turn color output on/off for those drivers/devices\n"
20232 " that support it.\n"
20233 "\n"
20234 " Redacted form: plscolor(color)\n"
20235 "\n"
20236 " This function is used in example 31.\n"
20237 "\n"
20238 "\n"
20239 "\n"
20240 "SYNOPSIS:\n"
20241 "\n"
20242 "plscolor(color)\n"
20243 "\n"
20244 "ARGUMENTS:\n"
20245 "\n"
20246 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
20247 " turned off. If non-zero, color is turned on.\n"
20248 "\n"
20249 ""},
20250 { "plscompression", _wrap_plscompression, METH_O, "\n"
20251 "Set device-compression level\n"
20252 "\n"
20253 "DESCRIPTION:\n"
20254 "\n"
20255 " Set device-compression level. Only used for drivers that provide\n"
20256 " compression. This function, if used, should be invoked before a call\n"
20257 " to plinit.\n"
20258 "\n"
20259 " Redacted form: plscompression(compression)\n"
20260 "\n"
20261 " This function is used in example 31.\n"
20262 "\n"
20263 "\n"
20264 "\n"
20265 "SYNOPSIS:\n"
20266 "\n"
20267 "plscompression(compression)\n"
20268 "\n"
20269 "ARGUMENTS:\n"
20270 "\n"
20271 " compression (PLINT, input) : The desired compression level. This is\n"
20272 " a device-dependent value. Currently only the jpeg and png devices\n"
20273 " use these values. For jpeg value is the jpeg quality which should\n"
20274 " normally be in the range 0-95. Higher values denote higher quality\n"
20275 " and hence larger image sizes. For png values are in the range -1\n"
20276 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
20277 " A value of -1 denotes the default zlib compression level. Values\n"
20278 " in the range 10-99 are divided by 10 and then used as the zlib\n"
20279 " compression level. Higher compression levels correspond to greater\n"
20280 " compression and small file sizes at the expense of more\n"
20281 " computation.\n"
20282 "\n"
20283 ""},
20284 { "plsdev", _wrap_plsdev, METH_O, "\n"
20285 "Set the device (keyword) name\n"
20286 "\n"
20287 "DESCRIPTION:\n"
20288 "\n"
20289 " Set the device (keyword) name.\n"
20290 "\n"
20291 " Redacted form: plsdev(devname)\n"
20292 "\n"
20293 " This function is used in examples 1, 14, and 20.\n"
20294 "\n"
20295 "\n"
20296 "\n"
20297 "SYNOPSIS:\n"
20298 "\n"
20299 "plsdev(devname)\n"
20300 "\n"
20301 "ARGUMENTS:\n"
20302 "\n"
20303 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20304 " containing the device name keyword of the required output device.\n"
20305 " If\n"
20306 " devname is NULL or if the first character of the string is a ``?'',\n"
20307 " the normal (prompted) start up is used.\n"
20308 "\n"
20309 ""},
20310 { "plsdidev", _wrap_plsdidev, METH_VARARGS, "\n"
20311 "Set parameters that define current device-space window\n"
20312 "\n"
20313 "DESCRIPTION:\n"
20314 "\n"
20315 " Set relative margin width, aspect ratio, and relative justification\n"
20316 " that define current device-space window. If you want to just use the\n"
20317 " previous value for any of these, just pass in the magic value\n"
20318 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
20319 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
20320 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
20321 " to a device-specific value.\n"
20322 "\n"
20323 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20324 "\n"
20325 " This function is used in example 31.\n"
20326 "\n"
20327 "\n"
20328 "\n"
20329 "SYNOPSIS:\n"
20330 "\n"
20331 "plsdidev(mar, aspect, jx, jy)\n"
20332 "\n"
20333 "ARGUMENTS:\n"
20334 "\n"
20335 " mar (PLFLT, input) : Relative margin width.\n"
20336 "\n"
20337 " aspect (PLFLT, input) : Aspect ratio.\n"
20338 "\n"
20339 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20340 " the range -0.5 to 0.5.\n"
20341 "\n"
20342 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20343 " the range -0.5 to 0.5.\n"
20344 "\n"
20345 ""},
20346 { "plsdimap", _wrap_plsdimap, METH_VARARGS, "\n"
20347 "Set up transformation from metafile coordinates\n"
20348 "\n"
20349 "DESCRIPTION:\n"
20350 "\n"
20351 " Set up transformation from metafile coordinates. The size of the plot\n"
20352 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20353 " general-purpose facility just yet (not sure why the user would need\n"
20354 " it, for one).\n"
20355 "\n"
20356 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20357 " dimypmm)\n"
20358 "\n"
20359 " This function is not used in any examples.\n"
20360 "\n"
20361 "\n"
20362 "\n"
20363 "SYNOPSIS:\n"
20364 "\n"
20365 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20366 "\n"
20367 "ARGUMENTS:\n"
20368 "\n"
20369 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
20370 "\n"
20371 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
20372 "\n"
20373 " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
20374 "\n"
20375 " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
20376 "\n"
20377 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20378 "\n"
20379 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20380 "\n"
20381 ""},
20382 { "plsdiori", _wrap_plsdiori, METH_O, "\n"
20383 "Set plot orientation\n"
20384 "\n"
20385 "DESCRIPTION:\n"
20386 "\n"
20387 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20388 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20389 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20390 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20391 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20392 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20393 " not called the default value of rot is 0.\n"
20394 "\n"
20395 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20396 " probably want to change the aspect ratio to a value suitable for the\n"
20397 " plot orientation using a call to plsdidev or the command-line options\n"
20398 " -a or -freeaspect. For more documentation of those options see the\n"
20399 " PLplot documentation. Such command-line options can be set internally\n"
20400 " using plsetopt or set directly using the command line and parsed using\n"
20401 " a call to plparseopts.\n"
20402 "\n"
20403 " Redacted form: plsdiori(rot)\n"
20404 "\n"
20405 " This function is not used in any examples.\n"
20406 "\n"
20407 "\n"
20408 "\n"
20409 "SYNOPSIS:\n"
20410 "\n"
20411 "plsdiori(rot)\n"
20412 "\n"
20413 "ARGUMENTS:\n"
20414 "\n"
20415 " rot (PLFLT, input) : Plot orientation parameter.\n"
20416 "\n"
20417 ""},
20418 { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, "\n"
20419 "Set parameters that define current plot-space window\n"
20420 "\n"
20421 "DESCRIPTION:\n"
20422 "\n"
20423 " Set relative minima and maxima that define the current plot-space\n"
20424 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20425 " xmax, and ymax are 0., 0., 1., and 1.\n"
20426 "\n"
20427 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20428 "\n"
20429 " This function is used in example 31.\n"
20430 "\n"
20431 "\n"
20432 "\n"
20433 "SYNOPSIS:\n"
20434 "\n"
20435 "plsdiplt(xmin, ymin, xmax, ymax)\n"
20436 "\n"
20437 "ARGUMENTS:\n"
20438 "\n"
20439 " xmin (PLFLT, input) : Relative minimum in x.\n"
20440 "\n"
20441 " ymin (PLFLT, input) : Relative minimum in y.\n"
20442 "\n"
20443 " xmax (PLFLT, input) : Relative maximum in x.\n"
20444 "\n"
20445 " ymax (PLFLT, input) : Relative maximum in y.\n"
20446 "\n"
20447 ""},
20448 { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, "\n"
20449 "Set parameters incrementally (zoom mode) that define current plot-space window\n"
20450 "\n"
20451 "DESCRIPTION:\n"
20452 "\n"
20453 " Set relative minima and maxima incrementally (zoom mode) that define\n"
20454 " the current plot-space window. This function has the same effect as\n"
20455 " plsdiplt if that function has not been previously called. Otherwise,\n"
20456 " this function implements zoom mode using the transformation min_used =\n"
20457 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20458 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20459 " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20460 "\n"
20461 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20462 "\n"
20463 " This function is used in example 31.\n"
20464 "\n"
20465 "\n"
20466 "\n"
20467 "SYNOPSIS:\n"
20468 "\n"
20469 "plsdiplz(xmin, ymin, xmax, ymax)\n"
20470 "\n"
20471 "ARGUMENTS:\n"
20472 "\n"
20473 " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20474 "\n"
20475 " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20476 "\n"
20477 " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20478 "\n"
20479 " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20480 "\n"
20481 ""},
20482 { "plseed", _wrap_plseed, METH_O, "\n"
20483 "Set seed for internal random number generator.\n"
20484 "\n"
20485 "DESCRIPTION:\n"
20486 "\n"
20487 " Set the seed for the internal random number generator. See plrandd for\n"
20488 " further details.\n"
20489 "\n"
20490 " Redacted form: plseed(seed)\n"
20491 "\n"
20492 " This function is used in example 21.\n"
20493 "\n"
20494 "\n"
20495 "\n"
20496 "SYNOPSIS:\n"
20497 "\n"
20498 "plseed(seed)\n"
20499 "\n"
20500 "ARGUMENTS:\n"
20501 "\n"
20502 " seed (unsigned int, input) : Seed for random number generator.\n"
20503 "\n"
20504 ""},
20505 { "plsesc", _wrap_plsesc, METH_O, "\n"
20506 "Set the escape character for text strings\n"
20507 "\n"
20508 "DESCRIPTION:\n"
20509 "\n"
20510 " Set the escape character for text strings. From C (in contrast to\n"
20511 " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
20512 " characters are allowed to prevent the user from shooting himself in\n"
20513 " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
20514 " use of backslash as a character escape). Here are the allowed escape\n"
20515 " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
20516 " #, ASCII 35\n"
20517 " $, ASCII 36\n"
20518 " %, ASCII 37\n"
20519 " &, ASCII 38\n"
20520 " *, ASCII 42\n"
20521 " @, ASCII 64\n"
20522 " ^, ASCII 94\n"
20523 " ~, ASCII 126\n"
20524 "\n"
20525 "\n"
20526 " Redacted form: General: plsesc(esc)\n"
20527 "\n"
20528 "\n"
20529 " This function is used in example 29.\n"
20530 "\n"
20531 "\n"
20532 "\n"
20533 "SYNOPSIS:\n"
20534 "\n"
20535 "plsesc(esc)\n"
20536 "\n"
20537 "ARGUMENTS:\n"
20538 "\n"
20539 " esc (char, input) : Escape character.\n"
20540 "\n"
20541 ""},
20542 { "plsetopt", _wrap_plsetopt, METH_VARARGS, "\n"
20543 "Set any command-line option\n"
20544 "\n"
20545 "DESCRIPTION:\n"
20546 "\n"
20547 " Set any command-line option internally from a program before it\n"
20548 " invokes plinit. opt is the name of the command-line option and optarg\n"
20549 " is the corresponding command-line option argument.\n"
20550 "\n"
20551 " This function returns 0 on success.\n"
20552 "\n"
20553 " Redacted form: plsetopt(opt, optarg)\n"
20554 "\n"
20555 " This function is used in example 14.\n"
20556 "\n"
20557 "\n"
20558 "\n"
20559 "SYNOPSIS:\n"
20560 "\n"
20561 "PLINT plsetopt(opt, optarg)\n"
20562 "\n"
20563 "ARGUMENTS:\n"
20564 "\n"
20565 " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20566 " the command-line option.\n"
20567 "\n"
20568 " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20569 " containing the argument of the command-line option.\n"
20570 "\n"
20571 ""},
20572 { "plsfam", _wrap_plsfam, METH_VARARGS, "\n"
20573 "Set family file parameters\n"
20574 "\n"
20575 "DESCRIPTION:\n"
20576 "\n"
20577 " Sets variables dealing with output file familying. Does nothing if\n"
20578 " familying not supported by the driver. This routine, if used, must be\n"
20579 " called before initializing PLplot. See the PLplot documentation for\n"
20580 " more information.\n"
20581 "\n"
20582 " Redacted form: plsfam(fam, num, bmax)\n"
20583 "\n"
20584 " This function is used in examples 14 and 31.\n"
20585 "\n"
20586 "\n"
20587 "\n"
20588 "SYNOPSIS:\n"
20589 "\n"
20590 "plsfam(fam, num, bmax)\n"
20591 "\n"
20592 "ARGUMENTS:\n"
20593 "\n"
20594 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20595 " is enabled.\n"
20596 "\n"
20597 " num (PLINT, input) : Current family file number.\n"
20598 "\n"
20599 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20600 " file.\n"
20601 "\n"
20602 ""},
20603 { "plsfci", _wrap_plsfci, METH_O, "\n"
20604 "Set FCI (font characterization integer)\n"
20605 "\n"
20606 "DESCRIPTION:\n"
20607 "\n"
20608 " Sets font characteristics to be used at the start of the next string\n"
20609 " using the FCI approach. See the PLplot documentation for more\n"
20610 " information. Note, plsfont (which calls plsfci internally) provides a\n"
20611 " more user-friendly API for setting the font characterisitics.\n"
20612 "\n"
20613 " Redacted form: General: plsfci(fci)\n"
20614 "\n"
20615 "\n"
20616 " This function is used in example 23.\n"
20617 "\n"
20618 "\n"
20619 "\n"
20620 "SYNOPSIS:\n"
20621 "\n"
20622 "plsfci(fci)\n"
20623 "\n"
20624 "ARGUMENTS:\n"
20625 "\n"
20626 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20627 " of FCI.\n"
20628 "\n"
20629 ""},
20630 { "plsfnam", _wrap_plsfnam, METH_O, "\n"
20631 "Set output file name\n"
20632 "\n"
20633 "DESCRIPTION:\n"
20634 "\n"
20635 " Sets the current output file name, if applicable. If the file name\n"
20636 " has not been specified and is required by the driver, the user will be\n"
20637 " prompted for it. If using the X-windows output driver, this sets the\n"
20638 " display name. This routine, if used, must be called before\n"
20639 " initializing PLplot.\n"
20640 "\n"
20641 " Redacted form: plsfnam(fnam)\n"
20642 "\n"
20643 " This function is used in examples 1 and 20.\n"
20644 "\n"
20645 "\n"
20646 "\n"
20647 "SYNOPSIS:\n"
20648 "\n"
20649 "plsfnam(fnam)\n"
20650 "\n"
20651 "ARGUMENTS:\n"
20652 "\n"
20653 " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20654 " the file name.\n"
20655 "\n"
20656 ""},
20657 { "plsfont", _wrap_plsfont, METH_VARARGS, "\n"
20658 "Set family, style and weight of the current font\n"
20659 "\n"
20660 "DESCRIPTION:\n"
20661 "\n"
20662 " Sets the current font. See the PLplot documentation for more\n"
20663 " information on font selection.\n"
20664 "\n"
20665 " Redacted form: plsfont(family, style, weight)\n"
20666 "\n"
20667 " This function is used in example 23.\n"
20668 "\n"
20669 "\n"
20670 "\n"
20671 "SYNOPSIS:\n"
20672 "\n"
20673 "plsfont(family, style, weight)\n"
20674 "\n"
20675 "ARGUMENTS:\n"
20676 "\n"
20677 " family (PLINT, input) : Font family to select for the current font.\n"
20678 " The available values are given by the PL_FCI_* constants in\n"
20679 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20680 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20681 " signifies that the font family should not be altered.\n"
20682 "\n"
20683 " style (PLINT, input) : Font style to select for the current font.\n"
20684 " The available values are given by the PL_FCI_* constants in\n"
20685 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20686 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20687 " should not be altered.\n"
20688 "\n"
20689 " weight (PLINT, input) : Font weight to select for the current font.\n"
20690 " The available values are given by the PL_FCI_* constants in\n"
20691 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20692 " negative value signifies that the font weight should not be\n"
20693 " altered.\n"
20694 "\n"
20695 ""},
20696 { "plshades", _wrap_plshades, METH_VARARGS, "\n"
20697 "Shade regions on the basis of value\n"
20698 "\n"
20699 "DESCRIPTION:\n"
20700 "\n"
20701 " Shade regions on the basis of value. This is the high-level routine\n"
20702 " for making continuous color shaded plots with cmap1 while plshade\n"
20703 " should be used to plot individual shaded regions using either cmap0 or\n"
20704 " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20705 " our supported languages.\n"
20706 "\n"
20707 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20708 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20709 " pltr_data)\n"
20710 "\n"
20711 "\n"
20712 " This function is used in examples 16, 21, and 22.\n"
20713 "\n"
20714 "\n"
20715 "\n"
20716 "SYNOPSIS:\n"
20717 "\n"
20718 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20719 "\n"
20720 "ARGUMENTS:\n"
20721 "\n"
20722 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20723 " plot. Should have dimensions of\n"
20724 " nx by\n"
20725 " ny.\n"
20726 "\n"
20727 " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20728 "\n"
20729 " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20730 "\n"
20731 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20732 " the region that should be plotted in the shade plot. This\n"
20733 " function accepts x and y coordinates as input arguments and must\n"
20734 " return 1 if the point is to be included in the shade plot and 0\n"
20735 " otherwise. If you want to plot the entire shade plot (the usual\n"
20736 " case), this argument should be set to NULL.\n"
20737 "\n"
20738 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20739 " pltr below for how these arguments are used (only for the special case\n"
20740 " when the callback function\n"
20741 " pltr is not supplied).\n"
20742 "\n"
20743 " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20744 " corresponding to the edges of each shaded region that will be\n"
20745 " plotted by this function. To work properly the levels should be\n"
20746 " monotonic.\n"
20747 "\n"
20748 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20749 " of shade edge values in clevel).\n"
20750 "\n"
20751 " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20752 " pattern.\n"
20753 "\n"
20754 " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20755 " contours defining edges of shaded regions. The pen color is only\n"
20756 " temporary set for the contour drawing. Set this value to zero or\n"
20757 " less if no shade edge contours are wanted.\n"
20758 "\n"
20759 " cont_width (PLFLT, input) : Defines line width used for contours\n"
20760 " defining edges of shaded regions. This value may not be honored\n"
20761 " by all drivers. The pen width is only temporary set for the\n"
20762 " contour drawing. Set this value to zero or less if no shade edge\n"
20763 " contours are wanted.\n"
20764 "\n"
20765 " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20766 " region. Use plfill for this purpose.\n"
20767 "\n"
20768 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20769 " map to rectangles after coordinate transformation with pltrl.\n"
20770 " Otherwise, set rectangular to false. If rectangular is set to\n"
20771 " true, plshade tries to save time by filling large rectangles.\n"
20772 " This optimization fails if the coordinate transformation distorts\n"
20773 " the shape of rectangles. For example a plot in polar coordinates\n"
20774 " has to have rectangular set to false.\n"
20775 "\n"
20776 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20777 " defines the transformation between the zero-based indices of the\n"
20778 " matrix a and world coordinates. If\n"
20779 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20780 " indices of a are mapped to the range\n"
20781 " xmin through\n"
20782 " xmax and the y indices of a are mapped to the range\n"
20783 " ymin through\n"
20784 " ymax.For the C case, transformation functions are provided in the\n"
20785 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20786 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20787 " matrices. In addition, C callback routines for the transformation\n"
20788 " can be supplied by the user such as the mypltr function in\n"
20789 " examples/c/x09c.c which provides a general linear transformation\n"
20790 " between index coordinates and world coordinates.For languages\n"
20791 " other than C you should consult the PLplot documentation for the\n"
20792 " details concerning how PLTRANSFORM_callback arguments are\n"
20793 " interfaced. However, in general, a particular pattern of\n"
20794 " callback-associated arguments such as a tr vector with 6 elements;\n"
20795 " xg and yg vectors; or xg and yg matrices are respectively\n"
20796 " interfaced to a linear-transformation routine similar to the above\n"
20797 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20798 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20799 " support native language callbacks for handling index to\n"
20800 " world-coordinate transformations. Examples of these various\n"
20801 " approaches are given in examples/<language>x09*,\n"
20802 " examples/<language>x16*, examples/<language>x20*,\n"
20803 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20804 " supported languages.\n"
20805 "\n"
20806 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20807 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20808 " externally supplied.\n"
20809 "\n"
20810 ""},
20811 { "plshade", _wrap_plshade, METH_VARARGS, "\n"
20812 "Shade individual region on the basis of value\n"
20813 "\n"
20814 "DESCRIPTION:\n"
20815 "\n"
20816 " Shade individual region on the basis of value. Use plshades if you\n"
20817 " want to shade a number of contiguous regions using continuous colors.\n"
20818 " In particular the edge contours are treated properly in plshades. If\n"
20819 " you attempt to do contiguous regions with plshade the contours at the\n"
20820 " edge of the shade are partially obliterated by subsequent plots of\n"
20821 " contiguous shaded regions.\n"
20822 "\n"
20823 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20824 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20825 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20826 "\n"
20827 "\n"
20828 " This function is used in example 15.\n"
20829 "\n"
20830 "\n"
20831 "\n"
20832 "SYNOPSIS:\n"
20833 "\n"
20834 "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"
20835 "\n"
20836 "ARGUMENTS:\n"
20837 "\n"
20838 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20839 " plot. Should have dimensions of\n"
20840 " nx by\n"
20841 " ny.\n"
20842 "\n"
20843 " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20844 "\n"
20845 " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20846 "\n"
20847 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20848 " the region that should be plotted in the shade plot. This\n"
20849 " function accepts x and y coordinates as input arguments and must\n"
20850 " return 1 if the point is to be included in the shade plot and 0\n"
20851 " otherwise. If you want to plot the entire shade plot (the usual\n"
20852 " case), this argument should be set to NULL.\n"
20853 "\n"
20854 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20855 " pltr below for how these arguments are used (only for the special case\n"
20856 " when the callback function\n"
20857 " pltr is not supplied).\n"
20858 "\n"
20859 " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20860 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20861 "\n"
20862 " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20863 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20864 "\n"
20865 " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20866 " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20867 " then sh_color is interpreted as a cmap1 argument in the range\n"
20868 " (0.0-1.0).\n"
20869 "\n"
20870 " sh_color (PLFLT, input) : Defines color map index with integer\n"
20871 " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20872 "\n"
20873 " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20874 "\n"
20875 " min_color (PLINT, input) : Defines pen color, width used by the\n"
20876 " boundary of shaded region. The min values are used for the\n"
20877 " shade_min boundary, and the max values are used on the shade_max\n"
20878 " boundary. Set color and width to zero for no plotted boundaries.\n"
20879 "\n"
20880 " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20881 " boundary of shaded region. The min values are used for the\n"
20882 " shade_min boundary, and the max values are used on the shade_max\n"
20883 " boundary. Set color and width to zero for no plotted boundaries.\n"
20884 "\n"
20885 " max_color (PLINT, input) : Defines pen color, width used by the\n"
20886 " boundary of shaded region. The min values are used for the\n"
20887 " shade_min boundary, and the max values are used on the shade_max\n"
20888 " boundary. Set color and width to zero for no plotted boundaries.\n"
20889 "\n"
20890 " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20891 " boundary of shaded region. The min values are used for the\n"
20892 " shade_min boundary, and the max values are used on the shade_max\n"
20893 " boundary. Set color and width to zero for no plotted boundaries.\n"
20894 "\n"
20895 " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20896 " Use plfill. Future version of PLplot may have other fill\n"
20897 " routines.\n"
20898 "\n"
20899 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20900 " map to rectangles after coordinate transformation with pltrl.\n"
20901 " Otherwise, set rectangular to false. If rectangular is set to\n"
20902 " true, plshade tries to save time by filling large rectangles.\n"
20903 " This optimization fails if the coordinate transformation distorts\n"
20904 " the shape of rectangles. For example a plot in polar coordinates\n"
20905 " has to have rectangular set to false.\n"
20906 "\n"
20907 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20908 " defines the transformation between the zero-based indices of the\n"
20909 " matrix a and world coordinates. If\n"
20910 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20911 " indices of a are mapped to the range\n"
20912 " xmin through\n"
20913 " xmax and the y indices of a are mapped to the range\n"
20914 " ymin through\n"
20915 " ymax.For the C case, transformation functions are provided in the\n"
20916 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20917 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20918 " matrices. In addition, C callback routines for the transformation\n"
20919 " can be supplied by the user such as the mypltr function in\n"
20920 " examples/c/x09c.c which provides a general linear transformation\n"
20921 " between index coordinates and world coordinates.For languages\n"
20922 " other than C you should consult the PLplot documentation for the\n"
20923 " details concerning how PLTRANSFORM_callback arguments are\n"
20924 " interfaced. However, in general, a particular pattern of\n"
20925 " callback-associated arguments such as a tr vector with 6 elements;\n"
20926 " xg and yg vectors; or xg and yg matrices are respectively\n"
20927 " interfaced to a linear-transformation routine similar to the above\n"
20928 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20929 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20930 " support native language callbacks for handling index to\n"
20931 " world-coordinate transformations. Examples of these various\n"
20932 " approaches are given in examples/<language>x09*,\n"
20933 " examples/<language>x16*, examples/<language>x20*,\n"
20934 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20935 " supported languages.\n"
20936 "\n"
20937 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20938 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20939 " externally supplied.\n"
20940 "\n"
20941 ""},
20942 { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, "\n"
20943 "Assign a function to use for generating custom axis labels\n"
20944 "\n"
20945 "DESCRIPTION:\n"
20946 "\n"
20947 " This function allows a user to provide their own function to provide\n"
20948 " axis label text. The user function is given the numeric value for a\n"
20949 " point on an axis and returns a string label to correspond with that\n"
20950 " value. Custom axis labels can be enabled by passing appropriate\n"
20951 " arguments to plenv, plbox, plbox3 and similar functions.\n"
20952 "\n"
20953 " This function is used in example 19.\n"
20954 "\n"
20955 "\n"
20956 "\n"
20957 "SYNOPSIS:\n"
20958 "\n"
20959 "plslabelfunc(label_func, label_data)\n"
20960 "\n"
20961 "ARGUMENTS:\n"
20962 "\n"
20963 " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20964 " label function. In order to reset to the default labelling, set\n"
20965 " this to NULL. The labelling function parameters are, in order:\n"
20966 " axis: This indicates which axis a label is being requested for.\n"
20967 " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20968 "\n"
20969 " value: This is the value along the axis which is being labelled.\n"
20970 "\n"
20971 " label_text: The string representation of the label value.\n"
20972 "\n"
20973 " length: The maximum length in characters allowed for label_text.\n"
20974 "\n"
20975 "\n"
20976 " label_data (PLPointer, input) : This parameter may be used to pass\n"
20977 " data to the label_func function.\n"
20978 "\n"
20979 ""},
20980 { "plsmaj", _wrap_plsmaj, METH_VARARGS, "\n"
20981 "Set length of major ticks\n"
20982 "\n"
20983 "DESCRIPTION:\n"
20984 "\n"
20985 " This sets up the length of the major ticks. The actual length is the\n"
20986 " product of the default length and a scaling factor as for character\n"
20987 " height.\n"
20988 "\n"
20989 " Redacted form: plsmaj(def, scale)\n"
20990 "\n"
20991 " This function is used in example 29.\n"
20992 "\n"
20993 "\n"
20994 "\n"
20995 "SYNOPSIS:\n"
20996 "\n"
20997 "plsmaj(def, scale)\n"
20998 "\n"
20999 "ARGUMENTS:\n"
21000 "\n"
21001 " def (PLFLT, input) : The default length of a major tick in\n"
21002 " millimeters, should be set to zero if the default length is to\n"
21003 " remain unchanged.\n"
21004 "\n"
21005 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21006 " actual tick length.\n"
21007 "\n"
21008 ""},
21009 { "plsmem", _wrap_plsmem, METH_VARARGS, "\n"
21010 "Set the memory area to be plotted (RGB)\n"
21011 "\n"
21012 "DESCRIPTION:\n"
21013 "\n"
21014 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
21015 " the dev member of the stream structure. Also set the number of pixels\n"
21016 " in the memory passed in\n"
21017 " plotmem, which is a block of memory\n"
21018 " maxy by\n"
21019 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
21020 "\n"
21021 " This memory will have to be freed by the user!\n"
21022 "\n"
21023 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
21024 "\n"
21025 " This function is not used in any examples.\n"
21026 "\n"
21027 "\n"
21028 "\n"
21029 "SYNOPSIS:\n"
21030 "\n"
21031 "plsmem(maxx, maxy, plotmem)\n"
21032 "\n"
21033 "ARGUMENTS:\n"
21034 "\n"
21035 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21036 "\n"
21037 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21038 "\n"
21039 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21040 " user-supplied writeable memory area.\n"
21041 "\n"
21042 ""},
21043 { "plsmema", _wrap_plsmema, METH_VARARGS, "\n"
21044 "Set the memory area to be plotted (RGBA)\n"
21045 "\n"
21046 "DESCRIPTION:\n"
21047 "\n"
21048 " Set the memory area to be plotted (with the memcairo driver) as the\n"
21049 " dev member of the stream structure. Also set the number of pixels in\n"
21050 " the memory passed in\n"
21051 " plotmem, which is a block of memory\n"
21052 " maxy by\n"
21053 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
21054 "\n"
21055 " This memory will have to be freed by the user!\n"
21056 "\n"
21057 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
21058 "\n"
21059 " This function is not used in any examples.\n"
21060 "\n"
21061 "\n"
21062 "\n"
21063 "SYNOPSIS:\n"
21064 "\n"
21065 "plsmema(maxx, maxy, plotmem)\n"
21066 "\n"
21067 "ARGUMENTS:\n"
21068 "\n"
21069 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21070 "\n"
21071 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21072 "\n"
21073 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21074 " user-supplied writeable memory area.\n"
21075 "\n"
21076 ""},
21077 { "plsmin", _wrap_plsmin, METH_VARARGS, "\n"
21078 "Set length of minor ticks\n"
21079 "\n"
21080 "DESCRIPTION:\n"
21081 "\n"
21082 " This sets up the length of the minor ticks and the length of the\n"
21083 " terminals on error bars. The actual length is the product of the\n"
21084 " default length and a scaling factor as for character height.\n"
21085 "\n"
21086 " Redacted form: plsmin(def, scale)\n"
21087 "\n"
21088 " This function is used in example 29.\n"
21089 "\n"
21090 "\n"
21091 "\n"
21092 "SYNOPSIS:\n"
21093 "\n"
21094 "plsmin(def, scale)\n"
21095 "\n"
21096 "ARGUMENTS:\n"
21097 "\n"
21098 " def (PLFLT, input) : The default length of a minor tick in\n"
21099 " millimeters, should be set to zero if the default length is to\n"
21100 " remain unchanged.\n"
21101 "\n"
21102 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21103 " actual tick length.\n"
21104 "\n"
21105 ""},
21106 { "plsori", _wrap_plsori, METH_O, "\n"
21107 "Set orientation\n"
21108 "\n"
21109 "DESCRIPTION:\n"
21110 "\n"
21111 " Set integer plot orientation parameter. This function is identical to\n"
21112 " plsdiori except for the type of the argument, and should be used in\n"
21113 " the same way. See the documentation of plsdiori for details.\n"
21114 "\n"
21115 " Redacted form: plsori(ori)\n"
21116 "\n"
21117 " This function is used in example 3.\n"
21118 "\n"
21119 "\n"
21120 "\n"
21121 "SYNOPSIS:\n"
21122 "\n"
21123 "plsori(ori)\n"
21124 "\n"
21125 "ARGUMENTS:\n"
21126 "\n"
21127 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
21128 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
21129 " angle.\n"
21130 "\n"
21131 ""},
21132 { "plspage", _wrap_plspage, METH_VARARGS, "\n"
21133 "Set page parameters\n"
21134 "\n"
21135 "DESCRIPTION:\n"
21136 "\n"
21137 " Sets the page configuration (optional). If an individual parameter is\n"
21138 " zero then that parameter value is not updated. Not all parameters are\n"
21139 " recognized by all drivers and the interpretation is device-dependent.\n"
21140 " The X-window driver uses the length and offset parameters to determine\n"
21141 " the window size and location. The length and offset values are\n"
21142 " expressed in units that are specific to the current driver. For\n"
21143 " instance: screen drivers will usually interpret them as number of\n"
21144 " pixels, whereas printer drivers will usually use mm.\n"
21145 "\n"
21146 " This routine, if used, must be called before initializing PLplot. It\n"
21147 " may be called at later times for interactive drivers to change only\n"
21148 " the dpi for subsequent redraws which you can force via a call to\n"
21149 " plreplot. If this function is not called then the page size defaults\n"
21150 " to landscape A4 for drivers which use real world page sizes and 744\n"
21151 " pixels wide by 538 pixels high for raster drivers. The default value\n"
21152 " for dx and dy is 90 pixels per inch for raster drivers.\n"
21153 "\n"
21154 "\n"
21155 "\n"
21156 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21157 "\n"
21158 " This function is used in examples 14 and 31.\n"
21159 "\n"
21160 "\n"
21161 "\n"
21162 "SYNOPSIS:\n"
21163 "\n"
21164 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21165 "\n"
21166 "ARGUMENTS:\n"
21167 "\n"
21168 " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
21169 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21170 " (e.g. mm).\n"
21171 "\n"
21172 " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
21173 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21174 " (e.g. mm).\n"
21175 "\n"
21176 " xleng (PLINT, input) : Page length, x.\n"
21177 "\n"
21178 " yleng (PLINT, input) : Page length, y.\n"
21179 "\n"
21180 " xoff (PLINT, input) : Page offset, x.\n"
21181 "\n"
21182 " yoff (PLINT, input) : Page offset, y.\n"
21183 "\n"
21184 ""},
21185 { "plspal0", _wrap_plspal0, METH_O, "\n"
21186 "Set the cmap0 palette using the specified cmap0*.pal format file\n"
21187 "\n"
21188 "DESCRIPTION:\n"
21189 "\n"
21190 " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
21191 "\n"
21192 " Redacted form: plspal0(filename)\n"
21193 "\n"
21194 " This function is in example 16.\n"
21195 "\n"
21196 "\n"
21197 "\n"
21198 "SYNOPSIS:\n"
21199 "\n"
21200 "plspal0(filename)\n"
21201 "\n"
21202 "ARGUMENTS:\n"
21203 "\n"
21204 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21205 " containing the name of the cmap0*.pal file. If this string is\n"
21206 " empty, use the default cmap0*.pal file.\n"
21207 "\n"
21208 ""},
21209 { "plspal1", _wrap_plspal1, METH_VARARGS, "\n"
21210 "Set the cmap1 palette using the specified cmap1*.pal format file\n"
21211 "\n"
21212 "DESCRIPTION:\n"
21213 "\n"
21214 " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
21215 "\n"
21216 " Redacted form: plspal1(filename, interpolate)\n"
21217 "\n"
21218 " This function is used in example 16.\n"
21219 "\n"
21220 "\n"
21221 "\n"
21222 "SYNOPSIS:\n"
21223 "\n"
21224 "plspal1(filename, interpolate)\n"
21225 "\n"
21226 "ARGUMENTS:\n"
21227 "\n"
21228 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21229 " containing the name of the cmap1*.pal file. If this string is\n"
21230 " empty, use the default cmap1*.pal file.\n"
21231 "\n"
21232 " interpolate (PLBOOL, input) : If this parameter is true, the\n"
21233 " columns containing the intensity index, r, g, b, alpha and\n"
21234 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
21235 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
21236 " a flag which controls whether the r, g, b data sent to plscmap1la\n"
21237 " are interpreted as HLS or RGB.) If this parameter is false, the\n"
21238 " intensity index and alt_hue_path columns are ignored and the r, g,\n"
21239 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
21240 " are used instead to set the cmap1 palette directly with a call to\n"
21241 " plscmap1a.\n"
21242 "\n"
21243 ""},
21244 { "plspause", _wrap_plspause, METH_O, "\n"
21245 "Set the pause (on end-of-page) status\n"
21246 "\n"
21247 "DESCRIPTION:\n"
21248 "\n"
21249 " Set the pause (on end-of-page) status.\n"
21250 "\n"
21251 " Redacted form: plspause(pause)\n"
21252 "\n"
21253 " This function is in examples 14,20.\n"
21254 "\n"
21255 "\n"
21256 "\n"
21257 "SYNOPSIS:\n"
21258 "\n"
21259 "plspause(pause)\n"
21260 "\n"
21261 "ARGUMENTS:\n"
21262 "\n"
21263 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
21264 " end-of-page for those drivers which support this. Otherwise there\n"
21265 " is no pause.\n"
21266 "\n"
21267 ""},
21268 { "plsstrm", _wrap_plsstrm, METH_O, "\n"
21269 "Set current output stream\n"
21270 "\n"
21271 "DESCRIPTION:\n"
21272 "\n"
21273 " Sets the number of the current output stream. The stream number\n"
21274 " defaults to 0 unless changed by this routine. The first use of this\n"
21275 " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
21276 "\n"
21277 " Redacted form: plsstrm(strm)\n"
21278 "\n"
21279 " This function is examples 1,14,20.\n"
21280 "\n"
21281 "\n"
21282 "\n"
21283 "SYNOPSIS:\n"
21284 "\n"
21285 "plsstrm(strm)\n"
21286 "\n"
21287 "ARGUMENTS:\n"
21288 "\n"
21289 " strm (PLINT, input) : The current stream number.\n"
21290 "\n"
21291 ""},
21292 { "plssub", _wrap_plssub, METH_VARARGS, "\n"
21293 "Set the number of subpages in x and y\n"
21294 "\n"
21295 "DESCRIPTION:\n"
21296 "\n"
21297 " Set the number of subpages in x and y.\n"
21298 "\n"
21299 " Redacted form: plssub(nx, ny)\n"
21300 "\n"
21301 " This function is examples 1,2,14,21,25,27.\n"
21302 "\n"
21303 "\n"
21304 "\n"
21305 "SYNOPSIS:\n"
21306 "\n"
21307 "plssub(nx, ny)\n"
21308 "\n"
21309 "ARGUMENTS:\n"
21310 "\n"
21311 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
21312 " of window columns).\n"
21313 "\n"
21314 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
21315 " of window rows).\n"
21316 "\n"
21317 ""},
21318 { "plssym", _wrap_plssym, METH_VARARGS, "\n"
21319 "Set symbol size\n"
21320 "\n"
21321 "DESCRIPTION:\n"
21322 "\n"
21323 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
21324 " plsym. The actual height of a symbol is the product of the default\n"
21325 " symbol size and a scaling factor as for the character height.\n"
21326 "\n"
21327 " Redacted form: plssym(def, scale)\n"
21328 "\n"
21329 " This function is used in example 29.\n"
21330 "\n"
21331 "\n"
21332 "\n"
21333 "SYNOPSIS:\n"
21334 "\n"
21335 "plssym(def, scale)\n"
21336 "\n"
21337 "ARGUMENTS:\n"
21338 "\n"
21339 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
21340 " should be set to zero if the default height is to remain\n"
21341 " unchanged.\n"
21342 "\n"
21343 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21344 " actual symbol height.\n"
21345 "\n"
21346 ""},
21347 { "plstar", _wrap_plstar, METH_VARARGS, "\n"
21348 "Initialization\n"
21349 "\n"
21350 "DESCRIPTION:\n"
21351 "\n"
21352 " Initializing the plotting package. The program prompts for the device\n"
21353 " keyword or number of the desired output device. Hitting a RETURN in\n"
21354 " response to the prompt is the same as selecting the first device. If\n"
21355 " only one device is enabled when PLplot is installed, plstar will issue\n"
21356 " no prompt. The output device is divided into nx by ny subpages, each\n"
21357 " of which may be used independently. The subroutine pladv is used to\n"
21358 " advance from one subpage to the next.\n"
21359 "\n"
21360 " Redacted form: plstar(nx, ny)\n"
21361 "\n"
21362 " This function is used in example 1.\n"
21363 "\n"
21364 "\n"
21365 "\n"
21366 "SYNOPSIS:\n"
21367 "\n"
21368 "plstar(nx, ny)\n"
21369 "\n"
21370 "ARGUMENTS:\n"
21371 "\n"
21372 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21373 " x direction.\n"
21374 "\n"
21375 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21376 " y direction.\n"
21377 "\n"
21378 ""},
21379 { "plstart", _wrap_plstart, METH_VARARGS, "\n"
21380 "Initialization\n"
21381 "\n"
21382 "DESCRIPTION:\n"
21383 "\n"
21384 " Alternative to plstar for initializing the plotting package. The\n"
21385 " device name keyword for the desired output device must be supplied as\n"
21386 " an argument. These keywords are the same as those printed out by\n"
21387 " plstar. If the requested device is not available, or if the input\n"
21388 " string is empty or begins with ``?'', the prompted start up of plstar\n"
21389 " is used. This routine also divides the output device page into nx by\n"
21390 " ny subpages, each of which may be used independently. The subroutine\n"
21391 " pladv is used to advance from one subpage to the next.\n"
21392 "\n"
21393 " Redacted form: General: plstart(devname, nx, ny)\n"
21394 "\n"
21395 "\n"
21396 " This function is not used in any examples.\n"
21397 "\n"
21398 "\n"
21399 "\n"
21400 "SYNOPSIS:\n"
21401 "\n"
21402 "plstart(devname, nx, ny)\n"
21403 "\n"
21404 "ARGUMENTS:\n"
21405 "\n"
21406 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
21407 " containing the device name keyword of the required output device.\n"
21408 " If\n"
21409 " devname is NULL or if the first character of the string is a ``?'',\n"
21410 " the normal (prompted) start up is used.\n"
21411 "\n"
21412 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21413 " x direction.\n"
21414 "\n"
21415 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21416 " y direction.\n"
21417 "\n"
21418 ""},
21419 { "plstransform", _wrap_plstransform, METH_VARARGS, "\n"
21420 "Set a global coordinate transform function\n"
21421 "\n"
21422 "DESCRIPTION:\n"
21423 "\n"
21424 " This function can be used to define a coordinate transformation which\n"
21425 " affects all elements drawn within the current plot window. The\n"
21426 " coordinate_transform callback function is similar to that provided for\n"
21427 " the plmap and plmeridians functions. The coordinate_transform_data\n"
21428 " parameter may be used to pass extra data to coordinate_transform.\n"
21429 "\n"
21430 " Redacted form: General: plstransform(coordinate_transform,\n"
21431 " coordinate_transform_data)\n"
21432 "\n"
21433 "\n"
21434 " This function is used in examples 19 and 22.\n"
21435 "\n"
21436 "\n"
21437 "\n"
21438 "SYNOPSIS:\n"
21439 "\n"
21440 "plstransform(coordinate_transform, coordinate_transform_data)\n"
21441 "\n"
21442 "ARGUMENTS:\n"
21443 "\n"
21444 " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
21445 " function that defines the transformation from the input (x, y)\n"
21446 " world coordinates to new PLplot world coordinates. If\n"
21447 " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
21448 " case), then no transform is applied.\n"
21449 "\n"
21450 " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
21451 " for\n"
21452 " coordinate_transform.\n"
21453 "\n"
21454 ""},
21455 { "plstring", _wrap_plstring, METH_VARARGS, "\n"
21456 "Plot a glyph at the specified points\n"
21457 "\n"
21458 "DESCRIPTION:\n"
21459 "\n"
21460 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21461 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21462 " is specified with a PLplot user string. Note that the user string is\n"
21463 " not actually limited to one glyph so it is possible (but not normally\n"
21464 " useful) to plot more than one glyph at the specified points with this\n"
21465 " function. As with plmtex and plptex, the user string can contain FCI\n"
21466 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21467 " else PLplot escapes for Hershey or unicode text to determine the\n"
21468 " glyph.\n"
21469 "\n"
21470 " Redacted form: plstring(x, y, string)\n"
21471 "\n"
21472 " This function is used in examples 4, 21 and 26.\n"
21473 "\n"
21474 "\n"
21475 "\n"
21476 "SYNOPSIS:\n"
21477 "\n"
21478 "plstring(n, x, y, string)\n"
21479 "\n"
21480 "ARGUMENTS:\n"
21481 "\n"
21482 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21483 "\n"
21484 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21485 " the points.\n"
21486 "\n"
21487 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21488 " the points.\n"
21489 "\n"
21490 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21491 " the glyph(s) to be plotted at each of the n points.\n"
21492 "\n"
21493 ""},
21494 { "plstring3", _wrap_plstring3, METH_VARARGS, "\n"
21495 "Plot a glyph at the specified 3D points\n"
21496 "\n"
21497 "DESCRIPTION:\n"
21498 "\n"
21499 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21500 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21501 " this function similar to what is done for plline3. The glyph is\n"
21502 " specified with a PLplot user string. Note that the user string is not\n"
21503 " actually limited to one glyph so it is possible (but not normally\n"
21504 " useful) to plot more than one glyph at the specified points with this\n"
21505 " function. As with plmtex and plptex, the user string can contain FCI\n"
21506 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21507 " else PLplot escapes for Hershey or unicode text to determine the\n"
21508 " glyph.\n"
21509 "\n"
21510 " Redacted form: plstring3(x, y, z, string)\n"
21511 "\n"
21512 " This function is used in example 18.\n"
21513 "\n"
21514 "\n"
21515 "\n"
21516 "SYNOPSIS:\n"
21517 "\n"
21518 "plstring3(n, x, y, z, string)\n"
21519 "\n"
21520 "ARGUMENTS:\n"
21521 "\n"
21522 " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21523 "\n"
21524 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21525 " the points.\n"
21526 "\n"
21527 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21528 " the points.\n"
21529 "\n"
21530 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21531 " the points.\n"
21532 "\n"
21533 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21534 " the glyph(s) to be plotted at each of the n points. points.\n"
21535 "\n"
21536 ""},
21537 { "plstripa", _wrap_plstripa, METH_VARARGS, "\n"
21538 "Add a point to a strip chart\n"
21539 "\n"
21540 "DESCRIPTION:\n"
21541 "\n"
21542 " Add a point to a given pen of a given strip chart. There is no need\n"
21543 " for all pens to have the same number of points or to be equally\n"
21544 " sampled in the x coordinate. Allocates memory and rescales as\n"
21545 " necessary.\n"
21546 "\n"
21547 " Redacted form: plstripa(id, pen, x, y)\n"
21548 "\n"
21549 " This function is used in example 17.\n"
21550 "\n"
21551 "\n"
21552 "\n"
21553 "SYNOPSIS:\n"
21554 "\n"
21555 "plstripa(id, pen, x, y)\n"
21556 "\n"
21557 "ARGUMENTS:\n"
21558 "\n"
21559 " id (PLINT, input) : Identification number of the strip chart (set\n"
21560 " up in plstripc).\n"
21561 "\n"
21562 " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21563 "\n"
21564 " x (PLFLT, input) : X coordinate of point to plot.\n"
21565 "\n"
21566 " y (PLFLT, input) : Y coordinate of point to plot.\n"
21567 "\n"
21568 ""},
21569 { "plstripc", _wrap_plstripc, METH_VARARGS, "\n"
21570 "Create a 4-pen strip chart\n"
21571 "\n"
21572 "DESCRIPTION:\n"
21573 "\n"
21574 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21575 "\n"
21576 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21577 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21578 " styline, legline, labx, laby, labz)\n"
21579 "\n"
21580 "\n"
21581 " This function is used in example 17.\n"
21582 "\n"
21583 "\n"
21584 "\n"
21585 "SYNOPSIS:\n"
21586 "\n"
21587 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21588 "\n"
21589 "ARGUMENTS:\n"
21590 "\n"
21591 " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21592 " number of the strip chart to use on plstripa and plstripd.\n"
21593 "\n"
21594 " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21595 " the x-axis specification as in plbox.\n"
21596 "\n"
21597 " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21598 " the y-axis specification as in plbox.\n"
21599 "\n"
21600 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21601 " change as data are added.\n"
21602 "\n"
21603 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21604 " change as data are added.\n"
21605 "\n"
21606 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21607 " is multiplied by the factor (1 +\n"
21608 " xjump) .\n"
21609 "\n"
21610 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21611 " change as data are added.\n"
21612 "\n"
21613 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21614 " change as data are added.\n"
21615 "\n"
21616 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21617 "\n"
21618 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21619 "\n"
21620 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21621 " true, otherwise not.\n"
21622 "\n"
21623 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21624 " otherwise slide display.\n"
21625 "\n"
21626 " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21627 "\n"
21628 " collab (PLINT, input) : Legend color index (cmap0).\n"
21629 "\n"
21630 " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21631 " indices for the 4 pens.\n"
21632 "\n"
21633 " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21634 " indices for the 4 pens.\n"
21635 "\n"
21636 " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21637 " strings containing legends for the 4 pens.\n"
21638 "\n"
21639 " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21640 " the label for the x axis.\n"
21641 "\n"
21642 " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21643 " the label for the y axis.\n"
21644 "\n"
21645 " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21646 " the plot title.\n"
21647 "\n"
21648 ""},
21649 { "plstripd", _wrap_plstripd, METH_O, "\n"
21650 "Deletes and releases memory used by a strip chart\n"
21651 "\n"
21652 "DESCRIPTION:\n"
21653 "\n"
21654 " Deletes and releases memory used by a strip chart.\n"
21655 "\n"
21656 " Redacted form: plstripd(id)\n"
21657 "\n"
21658 " This function is used in example 17.\n"
21659 "\n"
21660 "\n"
21661 "\n"
21662 "SYNOPSIS:\n"
21663 "\n"
21664 "plstripd(id)\n"
21665 "\n"
21666 "ARGUMENTS:\n"
21667 "\n"
21668 " id (PLINT, input) : Identification number of strip chart to delete.\n"
21669 "\n"
21670 ""},
21671 { "plstyl", _wrap_plstyl, METH_VARARGS, "\n"
21672 "Set line style\n"
21673 "\n"
21674 "DESCRIPTION:\n"
21675 "\n"
21676 " This sets up the line style for all lines subsequently drawn. A line\n"
21677 " consists of segments in which the pen is alternately down and up. The\n"
21678 " lengths of these segments are passed in the vectors mark and space\n"
21679 " respectively. The number of mark-space pairs is specified by nms. In\n"
21680 " order to return the line style to the default continuous line, plstyl\n"
21681 " should be called with nms =0 .(see also pllsty)\n"
21682 "\n"
21683 " Redacted form: plstyl(mark, space)\n"
21684 "\n"
21685 " This function is used in examples 1, 9, and 14.\n"
21686 "\n"
21687 "\n"
21688 "\n"
21689 "SYNOPSIS:\n"
21690 "\n"
21691 "plstyl(nms, mark, space)\n"
21692 "\n"
21693 "ARGUMENTS:\n"
21694 "\n"
21695 " nms (PLINT, input) : The number of mark and space elements in a\n"
21696 " line. Thus a simple broken line can be obtained by setting nms=1\n"
21697 " . A continuous line is specified by setting nms=0 .\n"
21698 "\n"
21699 " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21700 " segments during which the pen is down, measured in micrometers.\n"
21701 "\n"
21702 " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21703 " the segments during which the pen is up, measured in micrometers.\n"
21704 "\n"
21705 ""},
21706 { "plsvect", _wrap_plsvect, METH_VARARGS, "\n"
21707 "Set arrow style for vector plots\n"
21708 "\n"
21709 "DESCRIPTION:\n"
21710 "\n"
21711 " Set the style for the arrow used by plvect to plot vectors.\n"
21712 "\n"
21713 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21714 "\n"
21715 " This function is used in example 22.\n"
21716 "\n"
21717 "\n"
21718 "\n"
21719 "SYNOPSIS:\n"
21720 "\n"
21721 "plsvect(arrowx, arrowy, npts, fill)\n"
21722 "\n"
21723 "ARGUMENTS:\n"
21724 "\n"
21725 " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21726 " the x and y points which make up the arrow. The arrow is plotted\n"
21727 " by joining these points to form a polygon. The scaling assumes\n"
21728 " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21729 " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21730 " will be reset to its default.\n"
21731 "\n"
21732 " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21733 " arrowy.\n"
21734 "\n"
21735 " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21736 " fill is false then the arrow is open.\n"
21737 "\n"
21738 ""},
21739 { "plsvpa", _wrap_plsvpa, METH_VARARGS, "\n"
21740 "Specify viewport in absolute coordinates\n"
21741 "\n"
21742 "DESCRIPTION:\n"
21743 "\n"
21744 " Alternate routine to plvpor for setting up the viewport. This routine\n"
21745 " should be used only if the viewport is required to have a definite\n"
21746 " size in millimeters. The routine plgspa is useful for finding out the\n"
21747 " size of the current subpage.\n"
21748 "\n"
21749 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21750 "\n"
21751 " This function is used in example 10.\n"
21752 "\n"
21753 "\n"
21754 "\n"
21755 "SYNOPSIS:\n"
21756 "\n"
21757 "plsvpa(xmin, xmax, ymin, ymax)\n"
21758 "\n"
21759 "ARGUMENTS:\n"
21760 "\n"
21761 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21762 " viewport from the left-hand edge of the subpage in millimeters.\n"
21763 "\n"
21764 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21765 " viewport from the left-hand edge of the subpage in millimeters.\n"
21766 "\n"
21767 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21768 " viewport from the bottom edge of the subpage in millimeters.\n"
21769 "\n"
21770 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21771 " from the bottom edge of the subpage in millimeters.\n"
21772 "\n"
21773 ""},
21774 { "plsxax", _wrap_plsxax, METH_VARARGS, "\n"
21775 "Set x axis parameters\n"
21776 "\n"
21777 "DESCRIPTION:\n"
21778 "\n"
21779 " Sets values of the digmax and digits flags for the x axis. See the\n"
21780 " PLplot documentation for more information.\n"
21781 "\n"
21782 " Redacted form: plsxax(digmax, digits)\n"
21783 "\n"
21784 " This function is used in example 31.\n"
21785 "\n"
21786 "\n"
21787 "\n"
21788 "SYNOPSIS:\n"
21789 "\n"
21790 "plsxax(digmax, digits)\n"
21791 "\n"
21792 "ARGUMENTS:\n"
21793 "\n"
21794 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21795 " digits for the x axis. If nonzero, the printed label will be\n"
21796 " switched to a floating-point representation when the number of\n"
21797 " digits exceeds digmax.\n"
21798 "\n"
21799 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21800 " its value here has no effect since it is set only by plbox or\n"
21801 " plbox3. However, the user may obtain its value after a call to\n"
21802 " either of these functions by calling plgxax.\n"
21803 "\n"
21804 ""},
21805 { "plsyax", _wrap_plsyax, METH_VARARGS, "\n"
21806 "Set y axis parameters\n"
21807 "\n"
21808 "DESCRIPTION:\n"
21809 "\n"
21810 " Identical to plsxax, except that arguments are flags for y axis. See\n"
21811 " the description of plsxax for more detail.\n"
21812 "\n"
21813 " Redacted form: plsyax(digmax, digits)\n"
21814 "\n"
21815 " This function is used in examples 1, 14, and 31.\n"
21816 "\n"
21817 "\n"
21818 "\n"
21819 "SYNOPSIS:\n"
21820 "\n"
21821 "plsyax(digmax, digits)\n"
21822 "\n"
21823 "ARGUMENTS:\n"
21824 "\n"
21825 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21826 " digits for the y axis. If nonzero, the printed label will be\n"
21827 " switched to a floating-point representation when the number of\n"
21828 " digits exceeds digmax.\n"
21829 "\n"
21830 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21831 " its value here has no effect since it is set only by plbox or\n"
21832 " plbox3. However, the user may obtain its value after a call to\n"
21833 " either of these functions by calling plgyax.\n"
21834 "\n"
21835 ""},
21836 { "plsym", _wrap_plsym, METH_VARARGS, "\n"
21837 "Plot a glyph at the specified points\n"
21838 "\n"
21839 "DESCRIPTION:\n"
21840 "\n"
21841 " Plot a glyph at the specified points. (This function is largely\n"
21842 " superseded by plstring which gives access to many[!] more glyphs.)\n"
21843 "\n"
21844 " Redacted form: plsym(x, y, code)\n"
21845 "\n"
21846 " This function is used in example 7.\n"
21847 "\n"
21848 "\n"
21849 "\n"
21850 "SYNOPSIS:\n"
21851 "\n"
21852 "plsym(n, x, y, code)\n"
21853 "\n"
21854 "ARGUMENTS:\n"
21855 "\n"
21856 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21857 "\n"
21858 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21859 " the points.\n"
21860 "\n"
21861 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21862 " the points.\n"
21863 "\n"
21864 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21865 " to be plotted at each of the n points.\n"
21866 "\n"
21867 ""},
21868 { "plszax", _wrap_plszax, METH_VARARGS, "\n"
21869 "Set z axis parameters\n"
21870 "\n"
21871 "DESCRIPTION:\n"
21872 "\n"
21873 " Identical to plsxax, except that arguments are flags for z axis. See\n"
21874 " the description of plsxax for more detail.\n"
21875 "\n"
21876 " Redacted form: plszax(digmax, digits)\n"
21877 "\n"
21878 " This function is used in example 31.\n"
21879 "\n"
21880 "\n"
21881 "\n"
21882 "SYNOPSIS:\n"
21883 "\n"
21884 "plszax(digmax, digits)\n"
21885 "\n"
21886 "ARGUMENTS:\n"
21887 "\n"
21888 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21889 " digits for the z axis. If nonzero, the printed label will be\n"
21890 " switched to a floating-point representation when the number of\n"
21891 " digits exceeds digmax.\n"
21892 "\n"
21893 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21894 " its value here has no effect since it is set only by plbox or\n"
21895 " plbox3. However, the user may obtain its value after a call to\n"
21896 " either of these functions by calling plgzax.\n"
21897 "\n"
21898 ""},
21899 { "pltext", _wrap_pltext, METH_NOARGS, "\n"
21900 "Switch to text screen\n"
21901 "\n"
21902 "DESCRIPTION:\n"
21903 "\n"
21904 " Sets an interactive device to text mode, used in conjunction with\n"
21905 " plgra to allow graphics and text to be interspersed. On a device\n"
21906 " which supports separate text and graphics windows, this command causes\n"
21907 " control to be switched to the text window. This can be useful for\n"
21908 " printing diagnostic messages or getting user input, which would\n"
21909 " otherwise interfere with the plots. The program must switch back to\n"
21910 " the graphics window before issuing plot commands, as the text (or\n"
21911 " console) device will probably become quite confused otherwise. If\n"
21912 " already in text mode, this command is ignored. It is also ignored on\n"
21913 " devices which only support a single window or use a different method\n"
21914 " for shifting focus (see also plgra).\n"
21915 "\n"
21916 " Redacted form: pltext()\n"
21917 "\n"
21918 " This function is used in example 1.\n"
21919 "\n"
21920 "\n"
21921 "\n"
21922 "SYNOPSIS:\n"
21923 "\n"
21924 "pltext()\n"
21925 "\n"
21926 ""},
21927 { "pltimefmt", _wrap_pltimefmt, METH_O, "\n"
21928 "Set format for date / time labels\n"
21929 "\n"
21930 "DESCRIPTION:\n"
21931 "\n"
21932 " Sets the format for date / time labels. To enable date / time format\n"
21933 " labels see the options to plbox, plbox3, and plenv.\n"
21934 "\n"
21935 " Redacted form: pltimefmt(fmt)\n"
21936 "\n"
21937 " This function is used in example 29.\n"
21938 "\n"
21939 "\n"
21940 "\n"
21941 "SYNOPSIS:\n"
21942 "\n"
21943 "pltimefmt(fmt)\n"
21944 "\n"
21945 "ARGUMENTS:\n"
21946 "\n"
21947 " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21948 " interpreted similarly to the format specifier of typical system\n"
21949 " strftime routines except that PLplot ignores locale and also\n"
21950 " supplies some useful extensions in the context of plotting. All\n"
21951 " text in the string is printed as-is other than conversion\n"
21952 " specifications which take the form of a '%' character followed by\n"
21953 " further conversion specification character. The conversion\n"
21954 " specifications which are similar to those provided by system\n"
21955 " strftime routines are the following: %a: The abbreviated (English)\n"
21956 " weekday name.\n"
21957 " %A: The full (English) weekday name.\n"
21958 " %b: The abbreviated (English) month name.\n"
21959 " %B: The full (English) month name.\n"
21960 " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21961 " %C: The century number (year/100) as a 2-digit integer.\n"
21962 " %d: The day of the month as a decimal number (range 01 to 31).\n"
21963 " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21964 " %e: Like %d, but a leading zero is replaced by a space.\n"
21965 " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21966 " %h: Equivalent to %b.\n"
21967 " %H: The hour as a decimal number using a 24-hour clock (range\n"
21968 " 00 to 23).\n"
21969 " %I: The hour as a decimal number using a 12-hour clock (range\n"
21970 " 01 to 12).\n"
21971 " %j: The day of the year as a decimal number (range 001 to\n"
21972 " 366).\n"
21973 " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21974 " 23); single digits are preceded by a blank. (See also %H.)\n"
21975 " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21976 " 12); single digits are preceded by a blank. (See also %I.)\n"
21977 " %m: The month as a decimal number (range 01 to 12).\n"
21978 " %M: The minute as a decimal number (range 00 to 59).\n"
21979 " %n: A newline character.\n"
21980 " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21981 " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21982 " %r: Equivalent to %I:%M:%S %p.\n"
21983 " %R: The time in 24-hour notation (%H:%M). For a version\n"
21984 " including the seconds, see %T below.\n"
21985 " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21986 " +0000 (UTC).\n"
21987 " %S: The second as a decimal number (range 00 to 60). (The\n"
21988 " range is up to 60 to allow for occasional leap seconds.)\n"
21989 " %t: A tab character.\n"
21990 " %T: The time in 24-hour notation (%H:%M:%S).\n"
21991 " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21992 " being 1. See also %w.\n"
21993 " %U: The week number of the current year as a decimal number,\n"
21994 " range 00 to 53, starting with the first Sunday as the first\n"
21995 " day of week 01. See also %V and %W.\n"
21996 " %v: Equivalent to %e-%b-%Y.\n"
21997 " %V: The ISO 8601 week number of the current year as a decimal\n"
21998 " number, range 01 to 53, where week 1 is the first week that\n"
21999 " has at least 4 days in the new year. See also %U and %W.\n"
22000 " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
22001 " being 0. See also %u.\n"
22002 " %W: The week number of the current year as a decimal number,\n"
22003 " range 00 to 53, starting with the first Monday as the first\n"
22004 " day of week 01.\n"
22005 " %x: Equivalent to %a %b %d %Y.\n"
22006 " %X: Equivalent to %T.\n"
22007 " %y: The year as a decimal number without a century (range 00\n"
22008 " to 99).\n"
22009 " %Y: The year as a decimal number including a century.\n"
22010 " %z: The UTC time-zone string = \"+0000\".\n"
22011 " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
22012 " %+: The UTC date and time in default format of the Unix date\n"
22013 " command which is equivalent to %a %b %d %T %Z %Y.\n"
22014 " %%: A literal \"%\" character.\n"
22015 " The conversion specifications which are extensions to those normally\n"
22016 " provided by system strftime routines are the following: %(0-9):\n"
22017 " The fractional part of the seconds field (including leading\n"
22018 " decimal point) to the specified accuracy. Thus %S%3 would give\n"
22019 " seconds to millisecond accuracy (00.000).\n"
22020 " %.: The fractional part of the seconds field (including\n"
22021 " leading decimal point) to the maximum available accuracy. Thus\n"
22022 " %S%. would give seconds with fractional part up to 9 decimal\n"
22023 " places if available.\n"
22024 "\n"
22025 ""},
22026 { "plvasp", _wrap_plvasp, METH_O, "\n"
22027 "Specify viewport using aspect ratio only\n"
22028 "\n"
22029 "DESCRIPTION:\n"
22030 "\n"
22031 " Selects the largest viewport with the given aspect ratio within the\n"
22032 " subpage that leaves a standard margin (left-hand margin of eight\n"
22033 " character heights, and a margin around the other three sides of five\n"
22034 " character heights).\n"
22035 "\n"
22036 " Redacted form: plvasp(aspect)\n"
22037 "\n"
22038 " This function is used in example 13.\n"
22039 "\n"
22040 "\n"
22041 "\n"
22042 "SYNOPSIS:\n"
22043 "\n"
22044 "plvasp(aspect)\n"
22045 "\n"
22046 "ARGUMENTS:\n"
22047 "\n"
22048 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22049 " axis of resulting viewport.\n"
22050 "\n"
22051 ""},
22052 { "plvect", _wrap_plvect, METH_VARARGS, "\n"
22053 "Vector plot\n"
22054 "\n"
22055 "DESCRIPTION:\n"
22056 "\n"
22057 " Draws a plot of vector data contained in the matrices (\n"
22058 " u[\n"
22059 " nx][\n"
22060 " ny],\n"
22061 " v[\n"
22062 " nx][\n"
22063 " ny]) . The scaling factor for the vectors is given by scale. A\n"
22064 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
22065 " additional data required by the transformation routine to map indices\n"
22066 " within the matrices to the world coordinates. The style of the vector\n"
22067 " arrow may be set using plsvect.\n"
22068 "\n"
22069 " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
22070 " discussion) the pltr, pltr_data callback arguments are sometimes\n"
22071 " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
22072 " with either one or two dimensions.\n"
22073 "\n"
22074 " This function is used in example 22.\n"
22075 "\n"
22076 "\n"
22077 "\n"
22078 "SYNOPSIS:\n"
22079 "\n"
22080 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
22081 "\n"
22082 "ARGUMENTS:\n"
22083 "\n"
22084 " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
22085 " and y components of the vector data to be plotted.\n"
22086 "\n"
22087 " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
22088 "\n"
22089 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
22090 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
22091 " automatically calculated for the data. If scale < 0 then the\n"
22092 " scaling factor is automatically calculated for the data and then\n"
22093 " multiplied by -\n"
22094 " scale. If scale > 0 then the scaling factor is set to scale.\n"
22095 "\n"
22096 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22097 " defines the transformation between the zero-based indices of the\n"
22098 " matrices u and v and world coordinates.For the C case,\n"
22099 " transformation functions are provided in the PLplot library: pltr0\n"
22100 " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
22101 " mappings respectively defined by vectors and matrices. In\n"
22102 " addition, C callback routines for the transformation can be\n"
22103 " supplied by the user such as the mypltr function in\n"
22104 " examples/c/x09c.c which provides a general linear transformation\n"
22105 " between index coordinates and world coordinates.For languages\n"
22106 " other than C you should consult the PLplot documentation for the\n"
22107 " details concerning how PLTRANSFORM_callback arguments are\n"
22108 " interfaced. However, in general, a particular pattern of\n"
22109 " callback-associated arguments such as a tr vector with 6 elements;\n"
22110 " xg and yg vectors; or xg and yg matrices are respectively\n"
22111 " interfaced to a linear-transformation routine similar to the above\n"
22112 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22113 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22114 " support native language callbacks for handling index to\n"
22115 " world-coordinate transformations. Examples of these various\n"
22116 " approaches are given in examples/<language>x09*,\n"
22117 " examples/<language>x16*, examples/<language>x20*,\n"
22118 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22119 " supported languages.\n"
22120 "\n"
22121 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22122 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
22123 " that is externally supplied.\n"
22124 "\n"
22125 ""},
22126 { "plvpas", _wrap_plvpas, METH_VARARGS, "\n"
22127 "Specify viewport using coordinates and aspect ratio\n"
22128 "\n"
22129 "DESCRIPTION:\n"
22130 "\n"
22131 " Device-independent routine for setting up the viewport. The viewport\n"
22132 " is chosen to be the largest with the given aspect ratio that fits\n"
22133 " within the specified region (in terms of normalized subpage\n"
22134 " coordinates). This routine is functionally equivalent to plvpor when\n"
22135 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
22136 " routine reserves no extra space at the edges for labels.\n"
22137 "\n"
22138 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22139 "\n"
22140 " This function is used in example 9.\n"
22141 "\n"
22142 "\n"
22143 "\n"
22144 "SYNOPSIS:\n"
22145 "\n"
22146 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22147 "\n"
22148 "ARGUMENTS:\n"
22149 "\n"
22150 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22151 " left-hand edge of the viewport.\n"
22152 "\n"
22153 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22154 " right-hand edge of the viewport.\n"
22155 "\n"
22156 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22157 " bottom edge of the viewport.\n"
22158 "\n"
22159 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22160 " edge of the viewport.\n"
22161 "\n"
22162 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22163 " axis.\n"
22164 "\n"
22165 ""},
22166 { "plvpor", _wrap_plvpor, METH_VARARGS, "\n"
22167 "Specify viewport using normalized subpage coordinates\n"
22168 "\n"
22169 "DESCRIPTION:\n"
22170 "\n"
22171 " Device-independent routine for setting up the viewport. This defines\n"
22172 " the viewport in terms of normalized subpage coordinates which run from\n"
22173 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
22174 " current subpage. Use the alternate routine plsvpa in order to create\n"
22175 " a viewport of a definite size.\n"
22176 "\n"
22177 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
22178 "\n"
22179 " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
22180 " 24, 26, 27, and 31.\n"
22181 "\n"
22182 "\n"
22183 "\n"
22184 "SYNOPSIS:\n"
22185 "\n"
22186 "plvpor(xmin, xmax, ymin, ymax)\n"
22187 "\n"
22188 "ARGUMENTS:\n"
22189 "\n"
22190 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22191 " left-hand edge of the viewport.\n"
22192 "\n"
22193 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22194 " right-hand edge of the viewport.\n"
22195 "\n"
22196 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22197 " bottom edge of the viewport.\n"
22198 "\n"
22199 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22200 " edge of the viewport.\n"
22201 "\n"
22202 ""},
22203 { "plvsta", _wrap_plvsta, METH_NOARGS, "\n"
22204 "Select standard viewport\n"
22205 "\n"
22206 "DESCRIPTION:\n"
22207 "\n"
22208 " Selects the largest viewport within the subpage that leaves a standard\n"
22209 " margin (left-hand margin of eight character heights, and a margin\n"
22210 " around the other three sides of five character heights).\n"
22211 "\n"
22212 " Redacted form: plvsta()\n"
22213 "\n"
22214 " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
22215 "\n"
22216 "\n"
22217 "\n"
22218 "SYNOPSIS:\n"
22219 "\n"
22220 "plvsta()\n"
22221 "\n"
22222 ""},
22223 { "plw3d", _wrap_plw3d, METH_VARARGS, "\n"
22224 "Configure the transformations required for projecting a 3D surface on a 2D window\n"
22225 "\n"
22226 "DESCRIPTION:\n"
22227 "\n"
22228 " Configure the transformations required for projecting a 3D surface on\n"
22229 " an existing 2D window. Those transformations (see the PLplot\n"
22230 " documentation) are done to a rectangular cuboid enclosing the 3D\n"
22231 " surface which has its limits expressed in 3D world coordinates and\n"
22232 " also normalized 3D coordinates (used for interpreting the altitude and\n"
22233 " azimuth of the viewing angle). The transformations consist of the\n"
22234 " linear transform from 3D world coordinates to normalized 3D\n"
22235 " coordinates, and the 3D rotation of normalized coordinates required to\n"
22236 " align the pole of the new 3D coordinate system with the viewing\n"
22237 " direction specified by altitude and azimuth so that x and y of the\n"
22238 " surface elements in that transformed coordinate system are the\n"
22239 " projection of the 3D surface with given viewing direction on the 2D\n"
22240 " window.\n"
22241 "\n"
22242 " The enclosing rectangular cuboid for the surface plot is defined by\n"
22243 " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
22244 " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
22245 " sizes of basex by basey by height so that xmin maps to -\n"
22246 " basex/2, xmax maps to basex/2, ymin maps to -\n"
22247 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
22248 " The resulting rectangular cuboid in normalized coordinates is then\n"
22249 " viewed by an observer at altitude alt and azimuth az. This routine\n"
22250 " must be called before plbox3 or any of the 3D surface plotting\n"
22251 " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
22252 " plsurf3dl or plfill3.\n"
22253 "\n"
22254 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
22255 " zmin, zmax, alt, az)\n"
22256 "\n"
22257 " This function is examples 8, 11, 18, and 21.\n"
22258 "\n"
22259 "\n"
22260 "\n"
22261 "SYNOPSIS:\n"
22262 "\n"
22263 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
22264 "\n"
22265 "ARGUMENTS:\n"
22266 "\n"
22267 " basex (PLFLT, input) : The normalized x coordinate size of the\n"
22268 " rectangular cuboid.\n"
22269 "\n"
22270 " basey (PLFLT, input) : The normalized y coordinate size of the\n"
22271 " rectangular cuboid.\n"
22272 "\n"
22273 " height (PLFLT, input) : The normalized z coordinate size of the\n"
22274 " rectangular cuboid.\n"
22275 "\n"
22276 " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
22277 " rectangular cuboid.\n"
22278 "\n"
22279 " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
22280 " rectangular cuboid.\n"
22281 "\n"
22282 " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
22283 " rectangular cuboid.\n"
22284 "\n"
22285 " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
22286 " rectangular cuboid.\n"
22287 "\n"
22288 " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
22289 " rectangular cuboid.\n"
22290 "\n"
22291 " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
22292 " rectangular cuboid.\n"
22293 "\n"
22294 " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
22295 " plane of the rectangular cuboid in normalized coordinates.\n"
22296 "\n"
22297 " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
22298 " rectangular cuboid in normalized coordinates. When az=0, the\n"
22299 " observer is looking face onto the zx plane of the rectangular\n"
22300 " cuboid in normalized coordinates, and as az is increased, the\n"
22301 " observer moves clockwise around that cuboid when viewed from above\n"
22302 " the xy plane.\n"
22303 "\n"
22304 ""},
22305 { "plwidth", _wrap_plwidth, METH_O, "\n"
22306 "Set pen width\n"
22307 "\n"
22308 "DESCRIPTION:\n"
22309 "\n"
22310 " Sets the pen width.\n"
22311 "\n"
22312 " Redacted form: plwidth(width)\n"
22313 "\n"
22314 " This function is used in examples 1 and 2.\n"
22315 "\n"
22316 "\n"
22317 "\n"
22318 "SYNOPSIS:\n"
22319 "\n"
22320 "plwidth(width)\n"
22321 "\n"
22322 "ARGUMENTS:\n"
22323 "\n"
22324 " width (PLFLT, input) : The desired pen width. If width is negative\n"
22325 " or the same as the previous value no action is taken. width = 0.\n"
22326 " should be interpreted as as the minimum valid pen width for the\n"
22327 " device. The interpretation of positive width values is also\n"
22328 " device dependent.\n"
22329 "\n"
22330 ""},
22331 { "plwind", _wrap_plwind, METH_VARARGS, "\n"
22332 "Specify window\n"
22333 "\n"
22334 "DESCRIPTION:\n"
22335 "\n"
22336 " Specify the window, i.e., the world coordinates of the edges of the\n"
22337 " viewport.\n"
22338 "\n"
22339 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
22340 "\n"
22341 " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
22342 " 29, and 31.\n"
22343 "\n"
22344 "\n"
22345 "\n"
22346 "SYNOPSIS:\n"
22347 "\n"
22348 "plwind(xmin, xmax, ymin, ymax)\n"
22349 "\n"
22350 "ARGUMENTS:\n"
22351 "\n"
22352 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
22353 " of the viewport.\n"
22354 "\n"
22355 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
22356 " of the viewport.\n"
22357 "\n"
22358 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
22359 " the viewport.\n"
22360 "\n"
22361 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
22362 " viewport.\n"
22363 "\n"
22364 ""},
22365 { "plxormod", _wrap_plxormod, METH_O, "\n"
22366 "Enter or leave xor mode\n"
22367 "\n"
22368 "DESCRIPTION:\n"
22369 "\n"
22370 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
22371 " those drivers (e.g., the xwin driver) that support it. Enables\n"
22372 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
22373 " is not capable of xor operation it returns a status of false.\n"
22374 "\n"
22375 " Redacted form: plxormod(mode, status)\n"
22376 "\n"
22377 " This function is used in examples 1 and 20.\n"
22378 "\n"
22379 "\n"
22380 "\n"
22381 "SYNOPSIS:\n"
22382 "\n"
22383 "plxormod(mode, status)\n"
22384 "\n"
22385 "ARGUMENTS:\n"
22386 "\n"
22387 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
22388 " is false means leave xor mode.\n"
22389 "\n"
22390 " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
22391 " modestatus of true (false) means driver is capable (incapable) of\n"
22392 " xor mode.\n"
22393 "\n"
22394 ""},
22395 { "plmap", _wrap_plmap, METH_VARARGS, "\n"
22396 "Plot continental outline or shapefile data in world coordinates\n"
22397 "\n"
22398 "DESCRIPTION:\n"
22399 "\n"
22400 " Plots continental outlines or shapefile data in world coordinates. A\n"
22401 " demonstration of how to use this function to create different\n"
22402 " projections can be found in examples/c/x19c. PLplot is provided with\n"
22403 " basic coastal outlines and USA state borders. To use the map\n"
22404 " functionality PLplot must be compiled with the shapelib library.\n"
22405 " Shapefiles have become a popular standard for geographical data and\n"
22406 " data in this format can be easily found from a number of online\n"
22407 " sources. Shapefile data is actually provided as three or more files\n"
22408 " with the same filename, but different extensions. The .shp and .shx\n"
22409 " files are required for plotting Shapefile data with PLplot.\n"
22410 "\n"
22411 " PLplot currently supports the point, multipoint, polyline and polygon\n"
22412 " objects within shapefiles. However holes in polygons are not\n"
22413 " supported. When plmap is used the type of object is derived from the\n"
22414 " shapefile, if you wish to override the type then use one of the other\n"
22415 " plmap variants. The built in maps have line data only.\n"
22416 "\n"
22417 " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
22418 "\n"
22419 " This function is used in example 19.\n"
22420 "\n"
22421 "\n"
22422 "\n"
22423 "SYNOPSIS:\n"
22424 "\n"
22425 "plmap(mapform, name, minx, maxx, miny, maxy)\n"
22426 "\n"
22427 "ARGUMENTS:\n"
22428 "\n"
22429 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22430 " transform the original map data coordinates to a new coordinate\n"
22431 " system. The PLplot-supplied map data is provided as latitudes and\n"
22432 " longitudes; other Shapefile data may be provided in other\n"
22433 " coordinate systems as can be found in their .prj plain text files.\n"
22434 " For example, by using this transform we can change from a\n"
22435 " longitude, latitude coordinate to a polar stereographic\n"
22436 " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
22437 " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
22438 " corresponding y coordinates (latitudes for the PLplot supplied\n"
22439 " data). After the call to mapform(), x[] and y[] should be\n"
22440 " replaced by the corresponding plot coordinates. If no transform is\n"
22441 " desired, mapform can be replaced by NULL.\n"
22442 "\n"
22443 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22444 " the type of map plotted. This is either one of the PLplot built-in\n"
22445 " maps or the file name of a set of Shapefile files without the file\n"
22446 " extensions. For the PLplot built-in maps the possible values are:\n"
22447 " \"globe\" -- continental outlines\n"
22448 " \"usa\" -- USA and state boundaries\n"
22449 " \"cglobe\" -- continental outlines and countries\n"
22450 " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
22451 "\n"
22452 "\n"
22453 " minx (PLFLT, input) : The minimum x value of map elements to be\n"
22454 " drawn. The units must match the shapefile (built in maps are\n"
22455 " degrees lat/lon). Objects in the file which do not encroach on the\n"
22456 " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
22457 " note this is simply an optimisation, not a clipping so for objects\n"
22458 " with some points inside the box and some points outside the box\n"
22459 " all the points will be rendered. These parameters also define\n"
22460 " latitude and longitude wrapping for shapefiles using these units.\n"
22461 " Longitude points will be wrapped by integer multiples of 360\n"
22462 " degrees to place them in the box. This allows the same data to be\n"
22463 " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
22464 " you plot from -180-540 you will get two cycles of data drawn. The\n"
22465 " value of minx must be less than the value of maxx. Passing in a\n"
22466 " nan, max/-max floating point number or +/-infinity will case the\n"
22467 " bounding box from the shapefile to be used.\n"
22468 "\n"
22469 " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22470 " drawn - see minx.\n"
22471 "\n"
22472 " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22473 " drawn - see minx.\n"
22474 "\n"
22475 " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22476 " drawn - see minx.\n"
22477 "\n"
22478 ""},
22479 { "plmapline", _wrap_plmapline, METH_VARARGS, "\n"
22480 "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22481 "\n"
22482 "DESCRIPTION:\n"
22483 "\n"
22484 " Plot all or a subset of Shapefile data using lines in world\n"
22485 " coordinates. Our 19th standard example demonstrates how to use this\n"
22486 " function. This function plots data from a Shapefile using lines as in\n"
22487 " plmap, however it also has the option of also only drawing specified\n"
22488 " elements from the Shapefile. The vector of indices of the required\n"
22489 " elements are passed as a function argument. The Shapefile data should\n"
22490 " include a metadata file (extension.dbf) listing all items within the\n"
22491 " Shapefile. This file can be opened by most popular spreadsheet\n"
22492 " programs and can be used to decide which indices to pass to this\n"
22493 " function.\n"
22494 "\n"
22495 " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22496 " plotentries)\n"
22497 "\n"
22498 " This function is used in example 19.\n"
22499 "\n"
22500 "\n"
22501 "\n"
22502 "SYNOPSIS:\n"
22503 "\n"
22504 "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22505 "\n"
22506 "ARGUMENTS:\n"
22507 "\n"
22508 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22509 " transform the coordinates given in the shapefile into a plot\n"
22510 " coordinate system. By using this transform, we can change from a\n"
22511 " longitude, latitude coordinate to a polar stereographic project,\n"
22512 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22513 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22514 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22515 " plot coordinates. If no transform is desired, mapform can be\n"
22516 " replaced by NULL.\n"
22517 "\n"
22518 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22519 " the file name of a set of Shapefile files without the file\n"
22520 " extension.\n"
22521 "\n"
22522 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22523 " be in the same units as used by the Shapefile. You could use a\n"
22524 " very large negative number to plot everything, but you can improve\n"
22525 " performance by limiting the area drawn. The units must match those\n"
22526 " of the Shapefile projection, which may be for example longitude or\n"
22527 " distance. The value of minx must be less than the value of maxx.\n"
22528 "\n"
22529 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22530 " use a very large number to plot everything, but you can improve\n"
22531 " performance by limiting the area drawn.\n"
22532 "\n"
22533 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22534 " be in the same units as used by the Shapefile. You could use a\n"
22535 " very large negative number to plot everything, but you can improve\n"
22536 " performance by limiting the area drawn. The units must match those\n"
22537 " of the Shapefile projection, which may be for example latitude or\n"
22538 " distance. The value of miny must be less than the value of maxy.\n"
22539 "\n"
22540 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22541 " use a very large number to plot everything, but you can improve\n"
22542 " performance by limiting the area drawn.\n"
22543 "\n"
22544 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22545 " zero-based indices of the Shapefile elements which will be drawn.\n"
22546 " Setting\n"
22547 " plotentries to NULL will plot all elements of the Shapefile.\n"
22548 "\n"
22549 " nplotentries (PLINT, input) : The number of items in\n"
22550 " plotentries. Ignored if\n"
22551 " plotentries is NULL.\n"
22552 "\n"
22553 ""},
22554 { "plmapstring", _wrap_plmapstring, METH_VARARGS, "\n"
22555 "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22556 "\n"
22557 "DESCRIPTION:\n"
22558 "\n"
22559 " As per plmapline, however the items are plotted as strings or points\n"
22560 " in the same way as plstring.\n"
22561 "\n"
22562 " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22563 " maxy, plotentries)\n"
22564 "\n"
22565 " This function is not used in any examples.\n"
22566 "\n"
22567 "\n"
22568 "\n"
22569 "SYNOPSIS:\n"
22570 "\n"
22571 "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22572 "\n"
22573 "ARGUMENTS:\n"
22574 "\n"
22575 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22576 " transform the coordinates given in the shapefile into a plot\n"
22577 " coordinate system. By using this transform, we can change from a\n"
22578 " longitude, latitude coordinate to a polar stereographic project,\n"
22579 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22580 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22581 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22582 " plot coordinates. If no transform is desired, mapform can be\n"
22583 " replaced by NULL.\n"
22584 "\n"
22585 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22586 " the file name of a set of Shapefile files without the file\n"
22587 " extension.\n"
22588 "\n"
22589 " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22590 " drawn.\n"
22591 "\n"
22592 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22593 " be in the same units as used by the Shapefile. You could use a\n"
22594 " very large negative number to plot everything, but you can improve\n"
22595 " performance by limiting the area drawn. The units must match those\n"
22596 " of the Shapefile projection, which may be for example longitude or\n"
22597 " distance. The value of minx must be less than the value of maxx.\n"
22598 "\n"
22599 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22600 " use a very large number to plot everything, but you can improve\n"
22601 " performance by limiting the area drawn.\n"
22602 "\n"
22603 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22604 " be in the same units as used by the Shapefile. You could use a\n"
22605 " very large negative number to plot everything, but you can improve\n"
22606 " performance by limiting the area drawn. The units must match those\n"
22607 " of the Shapefile projection, which may be for example latitude or\n"
22608 " distance. The value of miny must be less than the value of maxy.\n"
22609 "\n"
22610 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22611 " use a very large number to plot everything, but you can improve\n"
22612 " performance by limiting the area drawn.\n"
22613 "\n"
22614 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22615 " zero-based indices of the Shapefile elements which will be drawn.\n"
22616 " Setting\n"
22617 " plotentries to NULL will plot all elements of the Shapefile.\n"
22618 "\n"
22619 " nplotentries (PLINT, input) : The number of items in\n"
22620 " plotentries. Ignored if\n"
22621 " plotentries is NULL.\n"
22622 "\n"
22623 ""},
22624 { "plmaptex", _wrap_plmaptex, METH_VARARGS, "\n"
22625 "Draw text at points defined by Shapefile data in world coordinates\n"
22626 "\n"
22627 "DESCRIPTION:\n"
22628 "\n"
22629 " As per plmapline, however the items are plotted as text in the same\n"
22630 " way as plptex.\n"
22631 "\n"
22632 " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22633 " miny, maxy, plotentry)\n"
22634 "\n"
22635 " This function is used in example 19.\n"
22636 "\n"
22637 "\n"
22638 "\n"
22639 "SYNOPSIS:\n"
22640 "\n"
22641 "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22642 "\n"
22643 "ARGUMENTS:\n"
22644 "\n"
22645 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22646 " transform the coordinates given in the shapefile into a plot\n"
22647 " coordinate system. By using this transform, we can change from a\n"
22648 " longitude, latitude coordinate to a polar stereographic project,\n"
22649 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22650 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22651 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22652 " plot coordinates. If no transform is desired, mapform can be\n"
22653 " replaced by NULL.\n"
22654 "\n"
22655 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22656 " the file name of a set of Shapefile files without the file\n"
22657 " extension.\n"
22658 "\n"
22659 " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22660 " dy/dx.\n"
22661 "\n"
22662 " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22663 " dy/dx.\n"
22664 "\n"
22665 " just (PLFLT, input) : Set the justification of the text. The value\n"
22666 " given will be the fraction of the distance along the string that\n"
22667 " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22668 " centralized text and 1.0 gives right aligned text.\n"
22669 "\n"
22670 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22671 "\n"
22672 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22673 " be in the same units as used by the Shapefile. You could use a\n"
22674 " very large negative number to plot everything, but you can improve\n"
22675 " performance by limiting the area drawn. The units must match those\n"
22676 " of the Shapefile projection, which may be for example longitude or\n"
22677 " distance. The value of minx must be less than the value of maxx.\n"
22678 "\n"
22679 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22680 " use a very large number to plot everything, but you can improve\n"
22681 " performance by limiting the area drawn.\n"
22682 "\n"
22683 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22684 " be in the same units as used by the Shapefile. You could use a\n"
22685 " very large negative number to plot everything, but you can improve\n"
22686 " performance by limiting the area drawn. The units must match those\n"
22687 " of the Shapefile projection, which may be for example latitude or\n"
22688 " distance. The value of miny must be less than the value of maxy.\n"
22689 "\n"
22690 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22691 " use a very large number to plot everything, but you can improve\n"
22692 " performance by limiting the area drawn.\n"
22693 "\n"
22694 " plotentry (PLINT, input) : An integer indicating which text string\n"
22695 " of the Shapefile (zero indexed) will be drawn.\n"
22696 "\n"
22697 ""},
22698 { "plmapfill", _wrap_plmapfill, METH_VARARGS, "\n"
22699 "Plot all or a subset of Shapefile data, filling the polygons\n"
22700 "\n"
22701 "DESCRIPTION:\n"
22702 "\n"
22703 " As per plmapline, however the items are filled in the same way as\n"
22704 " plfill.\n"
22705 "\n"
22706 " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22707 " plotentries)\n"
22708 "\n"
22709 " This function is used in example 19.\n"
22710 "\n"
22711 "\n"
22712 "\n"
22713 "SYNOPSIS:\n"
22714 "\n"
22715 "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22716 "\n"
22717 "ARGUMENTS:\n"
22718 "\n"
22719 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22720 " transform the coordinates given in the shapefile into a plot\n"
22721 " coordinate system. By using this transform, we can change from a\n"
22722 " longitude, latitude coordinate to a polar stereographic project,\n"
22723 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22724 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22725 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22726 " plot coordinates. If no transform is desired, mapform can be\n"
22727 " replaced by NULL.\n"
22728 "\n"
22729 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22730 " the file name of a set of Shapefile files without the file\n"
22731 " extension.\n"
22732 "\n"
22733 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22734 " be in the same units as used by the Shapefile. You could use a\n"
22735 " very large negative number to plot everything, but you can improve\n"
22736 " performance by limiting the area drawn. The units must match those\n"
22737 " of the Shapefile projection, which may be for example longitude or\n"
22738 " distance. The value of minx must be less than the value of maxx.\n"
22739 "\n"
22740 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22741 " use a very large number to plot everything, but you can improve\n"
22742 " performance by limiting the area drawn.\n"
22743 "\n"
22744 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22745 " be in the same units as used by the Shapefile. You could use a\n"
22746 " very large negative number to plot everything, but you can improve\n"
22747 " performance by limiting the area drawn. The units must match those\n"
22748 " of the Shapefile projection, which may be for example latitude or\n"
22749 " distance. The value of miny must be less than the value of maxy.\n"
22750 "\n"
22751 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22752 " use a very large number to plot everything, but you can improve\n"
22753 " performance by limiting the area drawn.\n"
22754 "\n"
22755 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22756 " zero-based indices of the Shapefile elements which will be drawn.\n"
22757 " Setting\n"
22758 " plotentries to NULL will plot all elements of the Shapefile.\n"
22759 "\n"
22760 " nplotentries (PLINT, input) : The number of items in\n"
22761 " plotentries. Ignored if\n"
22762 " plotentries is NULL.\n"
22763 "\n"
22764 ""},
22765 { "plmeridians", _wrap_plmeridians, METH_VARARGS, "\n"
22766 "Plot latitude and longitude lines\n"
22767 "\n"
22768 "DESCRIPTION:\n"
22769 "\n"
22770 " Displays latitude and longitude on the current plot. The lines are\n"
22771 " plotted in the current color and line style.\n"
22772 "\n"
22773 " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22774 " minlat, maxlat)\n"
22775 "\n"
22776 " This function is used in example 19.\n"
22777 "\n"
22778 "\n"
22779 "\n"
22780 "SYNOPSIS:\n"
22781 "\n"
22782 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22783 "\n"
22784 "ARGUMENTS:\n"
22785 "\n"
22786 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22787 " transform the coordinate longitudes and latitudes to a plot\n"
22788 " coordinate system. By using this transform, we can change from a\n"
22789 " longitude, latitude coordinate to a polar stereographic project,\n"
22790 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22791 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22792 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22793 " plot coordinates. If no transform is desired, mapform can be\n"
22794 " replaced by NULL.\n"
22795 "\n"
22796 " dlong (PLFLT, input) : The interval in degrees at which the\n"
22797 " longitude lines are to be plotted.\n"
22798 "\n"
22799 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22800 " lines are to be plotted.\n"
22801 "\n"
22802 " minlong (PLFLT, input) : The value of the longitude on the left\n"
22803 " side of the plot. The value of minlong must be less than the value\n"
22804 " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22805 " equal to 360.\n"
22806 "\n"
22807 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22808 " side of the plot.\n"
22809 "\n"
22810 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22811 " background. One can always use -90.0 as the boundary outside the\n"
22812 " plot window will be automatically eliminated. However, the\n"
22813 " program will be faster if one can reduce the size of the\n"
22814 " background plotted.\n"
22815 "\n"
22816 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22817 " background. One can always use 90.0 as the boundary outside the\n"
22818 " plot window will be automatically eliminated.\n"
22819 "\n"
22820 ""},
22821 { "plimage", _wrap_plimage, METH_VARARGS, "\n"
22822 "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22823 "\n"
22824 "DESCRIPTION:\n"
22825 "\n"
22826 " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22827 " automatically adjusted to use the maximum and minimum values in idata\n"
22828 " as valuemin and valuemax in a call to plimagefr.\n"
22829 "\n"
22830 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22831 " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22832 "\n"
22833 "\n"
22834 " This function is used in example 20.\n"
22835 "\n"
22836 "\n"
22837 "\n"
22838 "SYNOPSIS:\n"
22839 "\n"
22840 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22841 "\n"
22842 "ARGUMENTS:\n"
22843 "\n"
22844 " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22845 " to plot. Should have dimensions of\n"
22846 " nx by\n"
22847 " ny.\n"
22848 "\n"
22849 " nx, ny (PLINT, input) : Dimensions of idata\n"
22850 "\n"
22851 " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22852 " are linearly transformed to these world coordinate ranges such\n"
22853 " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22854 " - 1] corresponds to (xmax, ymax).\n"
22855 "\n"
22856 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22857 " (inclusive) will be plotted.\n"
22858 "\n"
22859 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22860 " points whose plot coordinates fall inside the window of (Dxmin,\n"
22861 " Dymin) to (Dxmax, Dymax).\n"
22862 "\n"
22863 ""},
22864 { "plimagefr", _wrap_plimagefr, METH_VARARGS, "\n"
22865 "Plot a 2D matrix using cmap1\n"
22866 "\n"
22867 "DESCRIPTION:\n"
22868 "\n"
22869 " Plot a 2D matrix using cmap1.\n"
22870 "\n"
22871 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22872 " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22873 "\n"
22874 "\n"
22875 " This function is used in example 20.\n"
22876 "\n"
22877 "\n"
22878 "\n"
22879 "SYNOPSIS:\n"
22880 "\n"
22881 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22882 "\n"
22883 "ARGUMENTS:\n"
22884 "\n"
22885 " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22886 " plot. Should have dimensions of\n"
22887 " nx by\n"
22888 " ny.\n"
22889 "\n"
22890 " nx, ny (PLINT, input) : Dimensions of idata\n"
22891 "\n"
22892 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22893 " pltr below for how these arguments are used (only for the special case\n"
22894 " when the callback function\n"
22895 " pltr is not supplied).\n"
22896 "\n"
22897 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22898 " (inclusive) will be plotted.\n"
22899 "\n"
22900 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22901 " values to use for value to color mappings. A datum equal to or\n"
22902 " less than valuemin will be plotted with color 0.0, while a datum\n"
22903 " equal to or greater than valuemax will be plotted with color 1.0.\n"
22904 " Data between valuemin and valuemax map linearly to colors in the\n"
22905 " range (0.0-1.0).\n"
22906 "\n"
22907 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22908 " defines the transformation between the zero-based indices of the\n"
22909 " matrix idata and world coordinates. If\n"
22910 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22911 " indices of idata are mapped to the range\n"
22912 " xmin through\n"
22913 " xmax and the y indices of idata are mapped to the range\n"
22914 " ymin through\n"
22915 " ymax.For the C case, transformation functions are provided in the\n"
22916 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22917 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22918 " matrices. In addition, C callback routines for the transformation\n"
22919 " can be supplied by the user such as the mypltr function in\n"
22920 " examples/c/x09c.c which provides a general linear transformation\n"
22921 " between index coordinates and world coordinates.For languages\n"
22922 " other than C you should consult the PLplot documentation for the\n"
22923 " details concerning how PLTRANSFORM_callback arguments are\n"
22924 " interfaced. However, in general, a particular pattern of\n"
22925 " callback-associated arguments such as a tr vector with 6 elements;\n"
22926 " xg and yg vectors; or xg and yg matrices are respectively\n"
22927 " interfaced to a linear-transformation routine similar to the above\n"
22928 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22929 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22930 " support native language callbacks for handling index to\n"
22931 " world-coordinate transformations. Examples of these various\n"
22932 " approaches are given in examples/<language>x09*,\n"
22933 " examples/<language>x16*, examples/<language>x20*,\n"
22934 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22935 " supported languages.\n"
22936 "\n"
22937 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22938 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22939 " externally supplied.\n"
22940 "\n"
22941 ""},
22942 { "plClearOpts", _wrap_plClearOpts, METH_NOARGS, NULL},
22943 { "plResetOpts", _wrap_plResetOpts, METH_NOARGS, NULL},
22944 { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22945 { "plOptUsage", _wrap_plOptUsage, METH_NOARGS, NULL},
22946 { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_O, NULL},
22947 { "plGetCursor", _wrap_plGetCursor, METH_O, "\n"
22948 "Wait for graphics input event and translate to world coordinates.\n"
22949 "\n"
22950 "DESCRIPTION:\n"
22951 "\n"
22952 " Wait for graphics input event and translate to world coordinates.\n"
22953 " Returns 0 if no translation to world coordinates is possible.\n"
22954 "\n"
22955 " This function returns 1 on success and 0 if no translation to world\n"
22956 " coordinates is possible.\n"
22957 "\n"
22958 " Redacted form: plGetCursor(gin)\n"
22959 "\n"
22960 " This function is used in examples 1 and 20.\n"
22961 "\n"
22962 "\n"
22963 "\n"
22964 "SYNOPSIS:\n"
22965 "\n"
22966 "PLINT plGetCursor(gin)\n"
22967 "\n"
22968 "ARGUMENTS:\n"
22969 "\n"
22970 " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22971 " which will contain the output. The structure is not allocated by\n"
22972 " the routine and must exist before the function is called.\n"
22973 "\n"
22974 ""},
22975 { NULL, NULL, 0, NULL }
22976};
22977
22978
22979/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22980
22981static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22982static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22983static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22984static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22985static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
22986static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
22987static 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};
22988static 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};
22989static 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};
22990static 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};
22991static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
22992static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22993static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22994static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
22995
23012
23013static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
23014static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
23015static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
23016static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
23017static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
23023static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
23024static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
23025static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
23026static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
23027
23044
23045
23046/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23047
23049{0, 0, 0, 0.0, 0, 0}};
23050
23051#ifdef __cplusplus
23052}
23053#endif
23054/* -----------------------------------------------------------------------------
23055 * Type initialization:
23056 * This problem is tough by the requirement that no dynamic
23057 * memory is used. Also, since swig_type_info structures store pointers to
23058 * swig_cast_info structures and swig_cast_info structures store pointers back
23059 * to swig_type_info structures, we need some lookup code at initialization.
23060 * The idea is that swig generates all the structures that are needed.
23061 * The runtime then collects these partially filled structures.
23062 * The SWIG_InitializeModule function takes these initial arrays out of
23063 * swig_module, and does all the lookup, filling in the swig_module.types
23064 * array with the correct data and linking the correct swig_cast_info
23065 * structures together.
23066 *
23067 * The generated swig_type_info structures are assigned statically to an initial
23068 * array. We just loop through that array, and handle each type individually.
23069 * First we lookup if this type has been already loaded, and if so, use the
23070 * loaded structure instead of the generated one. Then we have to fill in the
23071 * cast linked list. The cast data is initially stored in something like a
23072 * two-dimensional array. Each row corresponds to a type (there are the same
23073 * number of rows as there are in the swig_type_initial array). Each entry in
23074 * a column is one of the swig_cast_info structures for that type.
23075 * The cast_initial array is actually an array of arrays, because each row has
23076 * a variable number of columns. So to actually build the cast linked list,
23077 * we find the array of casts associated with the type, and loop through it
23078 * adding the casts to the list. The one last trick we need to do is making
23079 * sure the type pointer in the swig_cast_info struct is correct.
23080 *
23081 * First off, we lookup the cast->type name to see if it is already loaded.
23082 * There are three cases to handle:
23083 * 1) If the cast->type has already been loaded AND the type we are adding
23084 * casting info to has not been loaded (it is in this module), THEN we
23085 * replace the cast->type pointer with the type pointer that has already
23086 * been loaded.
23087 * 2) If BOTH types (the one we are adding casting info to, and the
23088 * cast->type) are loaded, THEN the cast info has already been loaded by
23089 * the previous module so we just ignore it.
23090 * 3) Finally, if cast->type has not already been loaded, then we add that
23091 * swig_cast_info to the linked list (because the cast->type) pointer will
23092 * be correct.
23093 * ----------------------------------------------------------------------------- */
23094
23095#ifdef __cplusplus
23096extern "C" {
23097#if 0
23098} /* c-mode */
23099#endif
23100#endif
23101
23102#if 0
23103#define SWIGRUNTIME_DEBUG
23104#endif
23105
23106#ifndef SWIG_INIT_CLIENT_DATA_TYPE
23107#define SWIG_INIT_CLIENT_DATA_TYPE void *
23108#endif
23109
23110SWIGRUNTIME void
23112 size_t i;
23113 swig_module_info *module_head, *iter;
23114 int init;
23115
23116 /* check to see if the circular list has been setup, if not, set it up */
23117 if (swig_module.next==0) {
23118 /* Initialize the swig_module */
23119 swig_module.type_initial = swig_type_initial;
23120 swig_module.cast_initial = swig_cast_initial;
23121 swig_module.next = &swig_module;
23122 init = 1;
23123 } else {
23124 init = 0;
23125 }
23126
23127 /* Try and load any already created modules */
23128 module_head = SWIG_GetModule(clientdata);
23129 if (!module_head) {
23130 /* This is the first module loaded for this interpreter */
23131 /* so set the swig module into the interpreter */
23132 SWIG_SetModule(clientdata, &swig_module);
23133 } else {
23134 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
23135 iter=module_head;
23136 do {
23137 if (iter==&swig_module) {
23138 /* Our module is already in the list, so there's nothing more to do. */
23139 return;
23140 }
23141 iter=iter->next;
23142 } while (iter!= module_head);
23143
23144 /* otherwise we must add our module into the list */
23145 swig_module.next = module_head->next;
23146 module_head->next = &swig_module;
23147 }
23148
23149 /* When multiple interpreters are used, a module could have already been initialized in
23150 a different interpreter, but not yet have a pointer in this interpreter.
23151 In this case, we do not want to continue adding types... everything should be
23152 set up already */
23153 if (init == 0) return;
23154
23155 /* Now work on filling in swig_module.types */
23156#ifdef SWIGRUNTIME_DEBUG
23157 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
23158#endif
23159 for (i = 0; i < swig_module.size; ++i) {
23160 swig_type_info *type = 0;
23161 swig_type_info *ret;
23162 swig_cast_info *cast;
23163
23164#ifdef SWIGRUNTIME_DEBUG
23165 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23166#endif
23167
23168 /* if there is another module already loaded */
23169 if (swig_module.next != &swig_module) {
23170 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
23171 }
23172 if (type) {
23173 /* Overwrite clientdata field */
23174#ifdef SWIGRUNTIME_DEBUG
23175 printf("SWIG_InitializeModule: found type %s\n", type->name);
23176#endif
23177 if (swig_module.type_initial[i]->clientdata) {
23178 type->clientdata = swig_module.type_initial[i]->clientdata;
23179#ifdef SWIGRUNTIME_DEBUG
23180 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23181#endif
23182 }
23183 } else {
23184 type = swig_module.type_initial[i];
23185 }
23186
23187 /* Insert casting types */
23188 cast = swig_module.cast_initial[i];
23189 while (cast->type) {
23190 /* Don't need to add information already in the list */
23191 ret = 0;
23192#ifdef SWIGRUNTIME_DEBUG
23193 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23194#endif
23195 if (swig_module.next != &swig_module) {
23197#ifdef SWIGRUNTIME_DEBUG
23198 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23199#endif
23200 }
23201 if (ret) {
23202 if (type == swig_module.type_initial[i]) {
23203#ifdef SWIGRUNTIME_DEBUG
23204 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23205#endif
23206 cast->type = ret;
23207 ret = 0;
23208 } else {
23209 /* Check for casting already in the list */
23210 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23211#ifdef SWIGRUNTIME_DEBUG
23212 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23213#endif
23214 if (!ocast) ret = 0;
23215 }
23216 }
23217
23218 if (!ret) {
23219#ifdef SWIGRUNTIME_DEBUG
23220 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23221#endif
23222 if (type->cast) {
23223 type->cast->prev = cast;
23224 cast->next = type->cast;
23225 }
23226 type->cast = cast;
23227 }
23228 cast++;
23229 }
23230 /* Set entry in modules->types array equal to the type */
23231 swig_module.types[i] = type;
23232 }
23233 swig_module.types[i] = 0;
23234
23235#ifdef SWIGRUNTIME_DEBUG
23236 printf("**** SWIG_InitializeModule: Cast List ******\n");
23237 for (i = 0; i < swig_module.size; ++i) {
23238 int j = 0;
23239 swig_cast_info *cast = swig_module.cast_initial[i];
23240 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23241 while (cast->type) {
23242 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23243 cast++;
23244 ++j;
23245 }
23246 printf("---- Total casts: %d\n",j);
23247 }
23248 printf("**** SWIG_InitializeModule: Cast List ******\n");
23249#endif
23250}
23251
23252/* This function will propagate the clientdata field of type to
23253* any new swig_type_info structures that have been added into the list
23254* of equivalent types. It is like calling
23255* SWIG_TypeClientData(type, clientdata) a second time.
23256*/
23257SWIGRUNTIME void
23259 size_t i;
23260 swig_cast_info *equiv;
23261 static int init_run = 0;
23262
23263 if (init_run) return;
23264 init_run = 1;
23265
23266 for (i = 0; i < swig_module.size; i++) {
23267 if (swig_module.types[i]->clientdata) {
23268 equiv = swig_module.types[i]->cast;
23269 while (equiv) {
23270 if (!equiv->converter) {
23271 if (equiv->type && !equiv->type->clientdata)
23272 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
23273 }
23274 equiv = equiv->next;
23275 }
23276 }
23277 }
23278}
23279
23280#ifdef __cplusplus
23281#if 0
23282{
23283 /* c-mode */
23284#endif
23285}
23286#endif
23287
23288
23289
23290#ifdef __cplusplus
23291extern "C" {
23292#endif
23293
23294 /* -----------------------------------------------------------------------------
23295 * constants/methods manipulation
23296 * ----------------------------------------------------------------------------- */
23297
23298 /* Install Constants */
23299 SWIGINTERN void
23301 PyObject *obj = 0;
23302 size_t i;
23303 for (i = 0; constants[i].type; ++i) {
23304 switch(constants[i].type) {
23305 case SWIG_PY_POINTER:
23306 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23307 break;
23308 case SWIG_PY_BINARY:
23309 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23310 break;
23311 default:
23312 obj = 0;
23313 break;
23314 }
23315 if (obj) {
23316 PyDict_SetItemString(d, constants[i].name, obj);
23317 SWIG_Py_DECREF(obj);
23318 }
23319 }
23320 }
23321
23322 /* -----------------------------------------------------------------------------
23323 * Patch %callback methods' docstrings to hold the callback ptrs
23324 * -----------------------------------------------------------------------------*/
23325
23326 SWIGINTERN void
23327 SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
23328 size_t i;
23329 for (i = 0; methods[i].ml_name; ++i) {
23330 const char *c = methods[i].ml_doc;
23331 if (!c) continue;
23332 c = strstr(c, "swig_ptr: ");
23333 if (c) {
23334 int j;
23335 const swig_const_info *ci = 0;
23336 const char *name = c + 10;
23337 for (j = 0; const_table[j].type; ++j) {
23338 if (strncmp(const_table[j].name, name,
23339 strlen(const_table[j].name)) == 0) {
23340 ci = &(const_table[j]);
23341 break;
23342 }
23343 }
23344 if (ci) {
23345 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23346 if (ptr) {
23347 size_t shift = (ci->ptype) - types;
23348 swig_type_info *ty = types_initial[shift];
23349 size_t ldoc = (c - methods[i].ml_doc);
23350 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23351 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23352 if (ndoc) {
23353 char *buff = ndoc;
23354 memcpy(buff, methods[i].ml_doc, ldoc);
23355 buff += ldoc;
23356 memcpy(buff, "swig_ptr: ", 10);
23357 buff += 10;
23358 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23359 methods[i].ml_doc = ndoc;
23360 }
23361 }
23362 }
23363 }
23364 }
23365 }
23366
23367#ifdef __cplusplus
23368}
23369#endif
23370
23371
23372
23373
23374/* -----------------------------------------------------------------------------*
23375 * Partial Init method
23376 * -----------------------------------------------------------------------------*/
23377
23378#ifdef __cplusplus
23379extern "C"
23380#endif
23381
23383#if PY_VERSION_HEX >= 0x03000000
23384PyObject*
23385#else
23386void
23387#endif
23389 PyObject *m, *d, *md, *globals;
23390
23391#if PY_VERSION_HEX >= 0x03000000
23392 static struct PyModuleDef SWIG_module = {
23393 PyModuleDef_HEAD_INIT,
23394 SWIG_name,
23395 NULL,
23396 -1,
23398 NULL,
23399 NULL,
23400 NULL,
23401 NULL
23402 };
23403#endif
23404
23405#if defined(SWIGPYTHON_BUILTIN)
23406 static SwigPyClientData SwigPyObject_clientdata = {
23407 0, 0, 0, 0, 0, 0, 0
23408 };
23409 static PyGetSetDef this_getset_def = {
23410 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23411 };
23412 static SwigPyGetSet thisown_getset_closure = {
23415 };
23416 static PyGetSetDef thisown_getset_def = {
23417 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23418 };
23419 PyTypeObject *builtin_pytype;
23420 int builtin_base_count;
23421 swig_type_info *builtin_basetype;
23422 PyObject *tuple;
23423 PyGetSetDescrObject *static_getset;
23424 PyTypeObject *metatype;
23425 PyTypeObject *swigpyobject;
23426 SwigPyClientData *cd;
23427 PyObject *public_interface, *public_symbol;
23428 PyObject *this_descr;
23429 PyObject *thisown_descr;
23430 PyObject *self = 0;
23431 int i;
23432
23433 (void)builtin_pytype;
23434 (void)builtin_base_count;
23435 (void)builtin_basetype;
23436 (void)tuple;
23437 (void)static_getset;
23438 (void)self;
23439
23440 /* Metaclass is used to implement static member variables */
23441 metatype = SwigPyObjectType();
23442 assert(metatype);
23443#endif
23444
23445 (void)globals;
23446
23447 /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
23448 SWIG_This();
23451#ifndef SWIGPYTHON_BUILTIN
23453#endif
23454
23455 /* Fix SwigMethods to carry the callback ptrs when needed */
23457
23458#if PY_VERSION_HEX >= 0x03000000
23459 m = PyModule_Create(&SWIG_module);
23460#else
23461 m = Py_InitModule(SWIG_name, SwigMethods);
23462#endif
23463
23464 md = d = PyModule_GetDict(m);
23465 (void)md;
23466
23468
23469#ifdef SWIGPYTHON_BUILTIN
23470 swigpyobject = SwigPyObject_TypeOnce();
23471
23472 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23473 assert(SwigPyObject_stype);
23474 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23475 if (!cd) {
23476 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23477 SwigPyObject_clientdata.pytype = swigpyobject;
23478 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
23479 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23480# if PY_VERSION_HEX >= 0x03000000
23481 return NULL;
23482# else
23483 return;
23484# endif
23485 }
23486
23487 /* All objects have a 'this' attribute */
23488 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23489 (void)this_descr;
23490
23491 /* All objects have a 'thisown' attribute */
23492 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23493 (void)thisown_descr;
23494
23495 public_interface = PyList_New(0);
23496 public_symbol = 0;
23497 (void)public_symbol;
23498
23499 PyDict_SetItemString(md, "__all__", public_interface);
23500 SWIG_Py_DECREF(public_interface);
23501 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23502 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23503 for (i = 0; swig_const_table[i].name != 0; ++i)
23504 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23505#endif
23506
23508
23509
23510 import_array();
23511
23512 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23513 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23514 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23515 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23516 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23517 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23518 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23519 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23520 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23521 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23522 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23523 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23524 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23525 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23526 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23527 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23528 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23529 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23530 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23531 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23532 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23533 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23534 SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23535 SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23536 SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23537 SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23538 SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23539 SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23540 SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23541 SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23542 SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23543 SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23544 SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23545 SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23546 SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23547 SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23548 SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23549 SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23550 SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23551 SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23552 SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23553 SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23554 SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23555 SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23556 SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23557 SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23558 SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23559 SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23560 SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23561 SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23562 SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23563 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23564 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23565 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23566 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23567 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23568 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23569 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23570 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23571 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23572 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23573 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23574 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23575 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23576 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23577 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23578 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23579 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23580 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23581 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23582 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23583 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23584 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23585 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23586 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23587 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23588 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23589 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23590 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23591 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23592 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23593 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23594 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23595 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23596 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23597 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23598 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23599 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23600 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23601 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23602 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23603 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23604 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23605 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23606 SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23607 SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23608 SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23609 SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23610 SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23611 SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23612 SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23613 SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23614 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23615 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23616 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23617 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23618 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23619 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23620 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23621 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL0",SWIG_From_int((int)(16)));
23622 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL1",SWIG_From_int((int)(128)));
23623 SWIG_Python_SetConstant(d, "MIN_PLINT_RGB",SWIG_From_int((int)(0)));
23624 SWIG_Python_SetConstant(d, "MAX_PLINT_RGB",SWIG_From_int((int)(255)));
23625 SWIG_Python_SetConstant(d, "MIN_PLFLT_CMAP1",SWIG_From_double((double)(0.)));
23626 SWIG_Python_SetConstant(d, "MAX_PLFLT_CMAP1",SWIG_From_double((double)(1.)));
23627 SWIG_Python_SetConstant(d, "MIN_PLFLT_ALPHA",SWIG_From_double((double)(0.)));
23628 SWIG_Python_SetConstant(d, "MAX_PLFLT_ALPHA",SWIG_From_double((double)(1.)));
23629 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23630 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23631 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23632 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23633 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23634 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23635 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23636 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23637 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23638 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23639 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23640 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23641 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23642 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23643 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23644 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23645 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23646 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23647 SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23648 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23649 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23650 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23651 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23652 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23653 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23654 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23655 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23656 SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23657 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23658 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23659 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23660 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23661 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23662 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23663 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23664 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23665 SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23666 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23667 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23668 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23669 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23670 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23671 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23672 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23673 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23674 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23675 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23676 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23677 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23678 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23679 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23680 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23681 SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23682 SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23683 SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23684 SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23685 SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23686 SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23687 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23688 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23689 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23690 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23691 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23692 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23693 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23694 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23695 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23696 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23697#if PY_VERSION_HEX >= 0x03000000
23698 return m;
23699#else
23700 return;
23701#endif
23702}
23703
#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 int SWIG_AsVal_long(const octave_value &ov, long *val)
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
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)
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)
#define SWIG_TypeQuery(name)
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
#define SWIG_Py_XDECREF
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)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args)
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)
void cleanup_mapform(void)
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args)
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)
#define SWIG_Py_XINCREF
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args)
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)
#define SWIG_Py_DECREF
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
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
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)
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
SWIGINTERN PyObject * _wrap_pladv(PyObject *self, PyObject *args)
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)
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)
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)
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)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *self, PyObject *args)
#define SWIG_PY_BINARY
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *self, PyObject *args)
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *self, PyObject *args)
PyObject * python_f2eval
SWIGINTERN 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)
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)
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGINTERN PyObject * _wrap_plend1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *self, PyObject *args)
static PyMethodDef swigobject_methods[]
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *self, PyObject *args)
#define SWIG_AddCast(r)
void cleanup_PLcGrid1(void)
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
#define SWIG_IsNewObj(r)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *self, PyObject *args)
#define SWIG_InternalNewPointerObj(ptr, type, flags)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *self, PyObject *args)
#define NPY_PLFLT
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
#define SWIG_exception_fail(code, msg)
void cleanup_ct(void)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltr2(PyObject *self, PyObject *args)
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args)
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)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltr1(PyObject *self, PyObject *args)
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)
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)
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)
#define SWIG_Python_CallFunctor(functor, obj)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *self, PyObject *args)
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
PyObject * python_label
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
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)
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)
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)
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)
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)
#define SWIG_Py_INCREF
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
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)
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_Python_str_FromFormat
#define SWIG_InstallConstants(d, constants)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *self, PyObject *args)
static PyMethodDef SwigMethods[]
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj, int is_void)
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)
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)
SWIGINTERN PyObject * _wrap_plflush(PyObject *self, PyObject *args)
#define SWIG_IsTmpObj(r)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *self, PyObject *args)
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 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)
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)
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)
#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)
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 * _wrap_plenv0(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_PLcGrid
#define SWIG_BUILTIN_TP_INIT
SWIGINTERN void swig_varlink_dealloc(PyObject *o)
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v)
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)
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
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)
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)
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)
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)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
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)
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)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
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)
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)
SWIGINTERN PyObject * _wrap_plbox(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args)
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *self, PyObject *args)
enum callback_type pltr_type
SWIGINTERN PyObject * _wrap_plaxes(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
#define MY_UNBLOCK_THREADS
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
static int _wrap_PLGraphicsIn_wX_get(lua_State *L)
static swig_cast_info * swig_cast_initial[]
static int _wrap_PLGraphicsIn_button_get(lua_State *L)
static int _wrap_PLGraphicsIn_keysym_get(lua_State *L)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
static int _wrap_PLGraphicsIn_subwindow_get(lua_State *L)
static int _wrap_plend(lua_State *L)
#define SWIG_POINTER_OWN
#define SWIG_SyntaxError
static swig_cast_info _swigc__p_f_double_double__int[]
static swig_cast_info _swigc__p_int[]
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
#define SWIG_BUFFER_SIZE
#define SWIG_TypeError
static PLINT Alen
static swig_cast_info _swigc__p_double[]
#define SWIGTYPE_p_PLGraphicsIn
static int _wrap_plGetCursor(lua_State *L)
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static int _wrap_PLGraphicsIn_pY_set(lua_State *L)
#define SWIG_RuntimeError
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
static int _wrap_PLGraphicsIn_state_get(lua_State *L)
#define SWIGRUNTIME
#define SWIG_RUNTIME_VERSION
#define SWIG_OLDOBJ
#define SWIG_ValueError
static int _wrap_new_PLGraphicsIn(lua_State *L)
static int _wrap_PLGraphicsIn_dX_get(lua_State *L)
static int _wrap_PLGraphicsIn_pY_get(lua_State *L)
static swig_type_info * swig_types[13]
static int _wrap_plResetOpts(lua_State *L)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
#define SWIG_AttributeError
static int _wrap_plot3dcl(lua_State *L)
static int _wrap_plOptUsage(lua_State *L)
static swig_module_info swig_module
static int _wrap_PLGraphicsIn_state_set(lua_State *L)
static PLINT Ylen
static swig_type_info _swigt__p_double
#define SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_POINTER_RELEASE
static int _wrap_PLGraphicsIn_string_get(lua_State *L)
static swig_type_info _swigt__p_p_char
static int _wrap_plend1(lua_State *L)
static swig_type_info _swigt__p_p_double
#define SWIG_POINTER_CLEAR
#define SWIGTYPE_p_int
static int _wrap_PLGraphicsIn_string_set(lua_State *L)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
static int _wrap_plClearOpts(lua_State *L)
static swig_cast_info _swigc__p_char[]
static int _wrap_plot3d(lua_State *L)
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
PLINT(* defined_func)(PLFLT, PLFLT)
static swig_cast_info _swigc__p_p_double[]
#define SWIGINTERN
static int _wrap_PLGraphicsIn_keysym_set(lua_State *L)
static int _wrap_PLGraphicsIn_dY_get(lua_State *L)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
#define SWIG_POINTER_NO_NULL
static int _wrap_PLGraphicsIn_type_get(lua_State *L)
struct swig_type_info *(* swig_dycast_func)(void **)
#define SWIG_IOError
#define SWIG_NullReferenceError
static int _wrap_PLGraphicsIn_type_set(lua_State *L)
#define SWIG_POINTER_DISOWN
static swig_type_info _swigt__p_PLGraphicsIn
static swig_type_info _swigt__p_f_double_double__int
static int _wrap_PLGraphicsIn_subwindow_set(lua_State *L)
static int _wrap_plot3dc(lua_State *L)
static int _wrap_PLGraphicsIn_wY_get(lua_State *L)
#define SWIG_NEWOBJ
#define SWIG_TMPOBJ
static int _wrap_PLGraphicsIn_dX_set(lua_State *L)
static int _wrap_PLGraphicsIn_wX_set(lua_State *L)
static swig_cast_info _swigc__p_unsigned_int[]
#define SWIG_fail
static swig_type_info _swigt__p_int
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
static int _wrap_plSetUsage(lua_State *L)
static int _wrap_PLGraphicsIn_pX_set(lua_State *L)
#define SWIG_ERROR_RELEASE_NOT_OWNED
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
static PLINT Xlen
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
#define SWIG_ERROR
#define SWIG_name
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
static int _wrap_PLGraphicsIn_button_set(lua_State *L)
static swig_type_info * swig_type_initial[]
static swig_cast_info _swigc__p_PLGraphicsIn[]
static swig_cast_info _swigc__p_p_char[]
static int _wrap_PLGraphicsIn_pX_get(lua_State *L)
#define SWIG_MemoryError
#define SWIG_SystemError
#define SWIG_DivisionByZero
#define SWIGTYPE_p_double
static swig_type_info _swigt__p_char
#define SWIG_OverflowError
#define SWIGEXPORT
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
#define SWIG_IndexError
static int _wrap_PLGraphicsIn_dY_set(lua_State *L)
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
#define SWIG_OK
static int _wrap_PLGraphicsIn_wY_set(lua_State *L)
#define SWIGINTERNINLINE
#define SWIGRUNTIMEINLINE
char string[PL_MAXKEY]
Definition plplot.h:440
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