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.3.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 0x040300
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 <float.h>
3347
3348
3349#include <math.h>
3350
3351
3353SWIG_CanCastAsInteger(double *d, double min, double max) {
3354 double x = *d;
3355 if ((min <= x && x <= max)) {
3356 double fx, cx, rd;
3357 errno = 0;
3358 fx = floor(x);
3359 cx = ceil(x);
3360 rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3361 if ((errno == EDOM) || (errno == ERANGE)) {
3362 errno = 0;
3363 } else {
3364 double summ, reps, diff;
3365 if (rd < x) {
3366 diff = x - rd;
3367 } else if (rd > x) {
3368 diff = rd - x;
3369 } else {
3370 return 1;
3371 }
3372 summ = rd + x;
3373 reps = diff/summ;
3374 if (reps < 8*DBL_EPSILON) {
3375 *d = rd;
3376 return 1;
3377 }
3378 }
3379 }
3380 return 0;
3381}
3382
3383
3384SWIGINTERN int
3385SWIG_AsVal_long (PyObject *obj, long* val)
3386{
3387#if PY_VERSION_HEX < 0x03000000
3388 if (PyInt_Check(obj)) {
3389 if (val) *val = PyInt_AsLong(obj);
3390 return SWIG_OK;
3391 } else
3392#endif
3393 if (PyLong_Check(obj)) {
3394 long v = PyLong_AsLong(obj);
3395 if (!PyErr_Occurred()) {
3396 if (val) *val = v;
3397 return SWIG_OK;
3398 } else {
3399 PyErr_Clear();
3400 return SWIG_OverflowError;
3401 }
3402 }
3403#ifdef SWIG_PYTHON_CAST_MODE
3404 {
3405 int dispatch = 0;
3406 long v = PyInt_AsLong(obj);
3407 if (!PyErr_Occurred()) {
3408 if (val) *val = v;
3409 return SWIG_AddCast(SWIG_OK);
3410 } else {
3411 PyErr_Clear();
3412 }
3413 if (!dispatch) {
3414 double d;
3415 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3416 // Largest double not larger than LONG_MAX (not portably calculated easily)
3417 // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
3418 // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
3419 const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
3420 // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
3421 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
3422 if (val) *val = (long)(d);
3423 return res;
3424 }
3425 }
3426 }
3427#endif
3428 return SWIG_TypeError;
3429}
3430
3431
3432SWIGINTERN int
3433SWIG_AsVal_int (PyObject * obj, int *val)
3434{
3435 long v;
3436 int res = SWIG_AsVal_long (obj, &v);
3437 if (SWIG_IsOK(res)) {
3438 if ((v < INT_MIN || v > INT_MAX)) {
3439 return SWIG_OverflowError;
3440 } else {
3441 if (val) *val = (int)(v);
3442 }
3443 }
3444 return res;
3445}
3446
3447
3448SWIGINTERN int
3449SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3450{
3451#if PY_VERSION_HEX < 0x03000000
3452 if (PyInt_Check(obj)) {
3453 long v = PyInt_AsLong(obj);
3454 if (v >= 0) {
3455 if (val) *val = v;
3456 return SWIG_OK;
3457 } else {
3458 return SWIG_OverflowError;
3459 }
3460 } else
3461#endif
3462 if (PyLong_Check(obj)) {
3463 unsigned long v = PyLong_AsUnsignedLong(obj);
3464 if (!PyErr_Occurred()) {
3465 if (val) *val = v;
3466 return SWIG_OK;
3467 } else {
3468 PyErr_Clear();
3469 return SWIG_OverflowError;
3470 }
3471 }
3472#ifdef SWIG_PYTHON_CAST_MODE
3473 {
3474 int dispatch = 0;
3475 unsigned long v = PyLong_AsUnsignedLong(obj);
3476 if (!PyErr_Occurred()) {
3477 if (val) *val = v;
3478 return SWIG_AddCast(SWIG_OK);
3479 } else {
3480 PyErr_Clear();
3481 }
3482 if (!dispatch) {
3483 double d;
3484 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3485 // Largest double not larger than ULONG_MAX (not portably calculated easily)
3486 // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
3487 // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
3488 const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
3489 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
3490 if (val) *val = (unsigned long)(d);
3491 return res;
3492 }
3493 }
3494 }
3495#endif
3496 return SWIG_TypeError;
3497}
3498
3499
3500SWIGINTERN int
3501SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3502{
3503 unsigned long v;
3504 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3505 if (SWIG_IsOK(res)) {
3506 if ((v > UINT_MAX)) {
3507 return SWIG_OverflowError;
3508 } else {
3509 if (val) *val = (unsigned int)(v);
3510 }
3511 }
3512 return res;
3513}
3514
3515
3516SWIGINTERNINLINE PyObject*
3518{
3519 return PyInt_FromSize_t((size_t) value);
3520}
3521
3522
3525{
3526 static swig_type_info* info = 0;
3527 if (!info) {
3528 info = SWIG_TypeQuery("_p_char");
3529 }
3530 return info;
3531}
3532
3533
3534/* Return string from Python obj. NOTE: obj must remain in scope in order
3535 to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
3536SWIGINTERN int
3537SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
3538{
3539#if PY_VERSION_HEX>=0x03000000
3540#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3541 if (PyBytes_Check(obj))
3542#else
3543 if (PyUnicode_Check(obj))
3544#endif
3545#else
3546 if (PyString_Check(obj))
3547#endif
3548 {
3549 char *cstr; Py_ssize_t len;
3550 PyObject *bytes = NULL;
3551 int ret = SWIG_OK;
3552 if (alloc)
3553 *alloc = SWIG_OLDOBJ;
3554#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3555 if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
3556 return SWIG_TypeError;
3557#else
3558 cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
3559 if (!cstr)
3560 return SWIG_TypeError;
3561 /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
3562 if (bytes && cptr) {
3563 if (alloc) {
3564 cstr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3565 *alloc = SWIG_NEWOBJ;
3566 } else {
3567 /* alloc must be set in order to clean up allocated memory */
3568 return SWIG_RuntimeError;
3569 }
3570 }
3571#endif
3572 if (cptr) *cptr = cstr;
3573 if (psize) *psize = len + 1;
3574 SWIG_Py_XDECREF(bytes);
3575 return ret;
3576 } else {
3577#if defined(SWIG_PYTHON_2_UNICODE)
3578#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3579#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3580#endif
3581#if PY_VERSION_HEX<0x03000000
3582 if (PyUnicode_Check(obj)) {
3583 char *cstr; Py_ssize_t len;
3584 if (!alloc && cptr) {
3585 return SWIG_RuntimeError;
3586 }
3587 obj = PyUnicode_AsUTF8String(obj);
3588 if (!obj)
3589 return SWIG_TypeError;
3590 if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3591 if (cptr) {
3592 if (alloc) *alloc = SWIG_NEWOBJ;
3593 *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3594 }
3595 if (psize) *psize = len + 1;
3596
3597 SWIG_Py_XDECREF(obj);
3598 return SWIG_OK;
3599 } else {
3600 SWIG_Py_XDECREF(obj);
3601 }
3602 }
3603#endif
3604#endif
3605
3606 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3607 if (pchar_descriptor) {
3608 void* vptr = 0;
3609 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3610 if (cptr) *cptr = (char *) vptr;
3611 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3612 if (alloc) *alloc = SWIG_OLDOBJ;
3613 return SWIG_OK;
3614 }
3615 }
3616 }
3617 return SWIG_TypeError;
3618}
3619
3620
3621SWIGINTERN int
3622SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3623{
3624 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3625 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3626 if (SWIG_IsOK(res)) {
3627 /* special case of single char conversion when we don't need space for NUL */
3628 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3629 if (csize <= size) {
3630 if (val) {
3631 if (csize) memcpy(val, cptr, csize*sizeof(char));
3632 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3633 }
3634 if (alloc == SWIG_NEWOBJ) {
3635 free((char*)cptr);
3636 res = SWIG_DelNewMask(res);
3637 }
3638 return res;
3639 }
3640 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3641 }
3642 return SWIG_TypeError;
3643}
3644
3645
3646SWIGINTERNINLINE PyObject *
3647SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3648{
3649 if (carray) {
3650 if (size > INT_MAX) {
3651 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3652 return pchar_descriptor ?
3653 SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3654 } else {
3655#if PY_VERSION_HEX >= 0x03000000
3656#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3657 return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3658#else
3659 return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3660#endif
3661#else
3662 return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3663#endif
3664 }
3665 } else {
3666 return SWIG_Py_Void();
3667 }
3668}
3669
3670
3671SWIGINTERN size_t
3672SWIG_strnlen(const char* s, size_t maxlen)
3673{
3674 const char *p;
3675 for (p = s; maxlen-- && *p; p++)
3676 ;
3677 return p - s;
3678}
3679
3680
3681
3682
3683
3684SWIGINTERN int
3685SWIG_AsVal_char (PyObject * obj, char *val)
3686{
3687 int res = SWIG_AsCharArray(obj, val, 1);
3688 if (!SWIG_IsOK(res)) {
3689 long v;
3690 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3691 if (SWIG_IsOK(res)) {
3692 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3693 if (val) *val = (char)(v);
3694 } else {
3695 res = SWIG_OverflowError;
3696 }
3697 }
3698 }
3699 return res;
3700}
3701
3702#ifdef __cplusplus
3703extern "C" {
3704#endif
3705
3706 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int type, int mindims, int maxdims );
3707
3708// some really twisted stuff to allow calling a single precision library from python
3709 PyArrayObject* myIntArray_ContiguousFromObject( PyObject* in, int PL_UNUSED( type ), int mindims, int maxdims )
3710 {
3711 PyArrayObject* tmp = (PyArrayObject *) PyArray_ContiguousFromObject( in, NPY_PLINT,
3712 mindims, maxdims );
3713 if ( !tmp )
3714 {
3715 // could be an incoming long array which can't be "safely" converted, do it anyway
3716 if ( PyArray_Check( in ) )
3717 {
3718 PyErr_Clear();
3719 tmp = (PyArrayObject *) PyArray_Cast( (PyArrayObject *) in, NPY_PLINT );
3720 }
3721 }
3722 return tmp;
3723 }
3724
3725
3726#define myArray_ContiguousFromObject PyArray_ContiguousFromObject
3727
3728SWIGINTERN PyObject *_wrap_pltr0(PyObject *self, PyObject *args) {
3729 PyObject *resultobj = 0;
3730 PLFLT arg1 ;
3731 PLFLT arg2 ;
3732 PLFLT *arg3 = (PLFLT *) 0 ;
3733 PLFLT *arg4 = (PLFLT *) 0 ;
3734 PLPointer arg5 = (PLPointer) 0 ;
3735 double val1 ;
3736 int ecode1 = 0 ;
3737 double val2 ;
3738 int ecode2 = 0 ;
3739 PLFLT temp3 ;
3740 int res3 = SWIG_TMPOBJ ;
3741 PLFLT temp4 ;
3742 int res4 = SWIG_TMPOBJ ;
3743 PyObject *swig_obj[2] ;
3744
3745 arg3 = &temp3;
3746 arg4 = &temp4;
3747 {
3748 arg5 = NULL;
3749 }
3750 (void)self;
3751 if (!SWIG_Python_UnpackTuple(args, "pltr0", 2, 2, swig_obj)) SWIG_fail;
3752 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3753 if (!SWIG_IsOK(ecode1)) {
3754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr0" "', argument " "1"" of type '" "PLFLT""'");
3755 }
3756 arg1 = (PLFLT)(val1);
3757 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3758 if (!SWIG_IsOK(ecode2)) {
3759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr0" "', argument " "2"" of type '" "PLFLT""'");
3760 }
3761 arg2 = (PLFLT)(val2);
3762 pltr0(arg1,arg2,arg3,arg4,arg5);
3763 resultobj = SWIG_Py_Void();
3764 if (SWIG_IsTmpObj(res3)) {
3765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
3766 } else {
3767 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
3769 }
3770 if (SWIG_IsTmpObj(res4)) {
3771 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
3772 } else {
3773 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3774 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
3775 }
3776 return resultobj;
3777fail:
3778 return NULL;
3779}
3780
3781
3782
3783 PyArrayObject *pltr_xg, *pltr_yg;
3786
3787 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg );
3788 void cleanup_PLcGrid1( void );
3789 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg );
3790 void cleanup_PLcGrid2( void );
3791
3792 PLcGrid* marshal_PLcGrid1( PyObject* input, int isimg )
3793 {
3794 // fprintf(stderr, "marshal PLcGrid1\n");
3795 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3796 {
3797 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3798 return NULL;
3799 }
3800 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3801 NPY_PLFLT, 1, 1 );
3802 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3803 NPY_PLFLT, 1, 1 );
3804 if ( pltr_xg == 0 || pltr_yg == 0 )
3805 {
3806 PyErr_SetString( PyExc_ValueError, "Expected a sequence to two 1D arrays." );
3807 return NULL;
3808 }
3809 tmpGrid1.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3810 tmpGrid1.ny = (PLINT) PyArray_DIMS( pltr_yg )[0];
3811 if ( isimg == 0 )
3812 {
3813 if ( Xlen != tmpGrid1.nx || Ylen != tmpGrid1.ny )
3814 {
3815 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3816 return NULL;
3817 }
3818 }
3819 else
3820 {
3821 if ( Xlen != tmpGrid1.nx - 1 || Ylen != tmpGrid1.ny - 1 )
3822 {
3823 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3824 return NULL;
3825 }
3826 }
3827 tmpGrid1.xg = (PLFLT *) PyArray_DATA( pltr_xg );
3828 tmpGrid1.yg = (PLFLT *) PyArray_DATA( pltr_yg );
3829 return &tmpGrid1;
3830 }
3831
3832 void cleanup_PLcGrid1( void )
3833 {
3834 // fprintf(stderr, "cleanup PLcGrid1\n");
3835 Py_CLEAR( pltr_xg );
3836 Py_CLEAR( pltr_yg );
3837 }
3838
3839 PLcGrid2* marshal_PLcGrid2( PyObject* input, int isimg )
3840 {
3841 int i, size;
3842 // fprintf(stderr, "marshal PLcGrid2\n");
3843 if ( !PySequence_Check( input ) || PySequence_Size( input ) != 2 )
3844 {
3845 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two arrays." );
3846 return NULL;
3847 }
3848 pltr_xg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 0 ),
3849 NPY_PLFLT, 2, 2 );
3850 pltr_yg = (PyArrayObject *) myArray_ContiguousFromObject( PySequence_Fast_GET_ITEM( input, 1 ),
3851 NPY_PLFLT, 2, 2 );
3852 if ( pltr_xg == 0 || pltr_yg == 0 )
3853 {
3854 PyErr_SetString( PyExc_ValueError, "Expected a sequence of two 2D arrays." );
3855 return NULL;
3856 }
3857 if ( PyArray_DIMS( pltr_xg )[0] != PyArray_DIMS( pltr_yg )[0] ||
3858 PyArray_DIMS( pltr_xg )[1] != PyArray_DIMS( pltr_yg )[1] )
3859 {
3860 PyErr_SetString( PyExc_ValueError, "Arrays must be same size." );
3861 return NULL;
3862 }
3863 tmpGrid2.nx = (PLINT) PyArray_DIMS( pltr_xg )[0];
3864 tmpGrid2.ny = (PLINT) PyArray_DIMS( pltr_xg )[1];
3865 if ( isimg == 0 )
3866 {
3867 if ( Xlen != tmpGrid2.nx || Ylen != tmpGrid2.ny )
3868 {
3869 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg." );
3870 return NULL;
3871 }
3872 }
3873 else
3874 {
3875 if ( Xlen != tmpGrid2.nx - 1 || Ylen != tmpGrid2.ny - 1 )
3876 {
3877 PyErr_SetString( PyExc_ValueError, "pltr arguments must have X and Y dimensions of first arg + 1." );
3878 return NULL;
3879 }
3880 }
3881 size = tmpGrid2.ny;
3882 tmpGrid2.xg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3883 for ( i = 0; i < tmpGrid2.nx; i++ )
3884 tmpGrid2.xg[i] = ( (PLFLT *) PyArray_DATA( pltr_xg ) + i * size );
3885 tmpGrid2.yg = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) tmpGrid2.nx );
3886 for ( i = 0; i < tmpGrid2.nx; i++ )
3887 tmpGrid2.yg[i] = ( (PLFLT *) PyArray_DATA( pltr_yg ) + i * size );
3888 return &tmpGrid2;
3889 }
3890
3891 void cleanup_PLcGrid2( void )
3892 {
3893 // fprintf(stderr, "cleanup PLcGrid2\n");
3894 free( tmpGrid2.xg );
3895 free( tmpGrid2.yg );
3896 Py_CLEAR( pltr_xg );
3897 Py_CLEAR( pltr_yg );
3898 }
3899
3900SWIGINTERN PyObject *_wrap_pltr1(PyObject *self, PyObject *args) {
3901 PyObject *resultobj = 0;
3902 PLFLT arg1 ;
3903 PLFLT arg2 ;
3904 PLFLT *arg3 = (PLFLT *) 0 ;
3905 PLFLT *arg4 = (PLFLT *) 0 ;
3906 PLcGrid *arg5 = (PLcGrid *) 0 ;
3907 double val1 ;
3908 int ecode1 = 0 ;
3909 double val2 ;
3910 int ecode2 = 0 ;
3911 PLFLT temp3 ;
3912 int res3 = SWIG_TMPOBJ ;
3913 PLFLT temp4 ;
3914 int res4 = SWIG_TMPOBJ ;
3915 PyObject *swig_obj[3] ;
3916
3917 arg3 = &temp3;
3918 arg4 = &temp4;
3919 (void)self;
3920 if (!SWIG_Python_UnpackTuple(args, "pltr1", 3, 3, swig_obj)) SWIG_fail;
3921 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3922 if (!SWIG_IsOK(ecode1)) {
3923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr1" "', argument " "1"" of type '" "PLFLT""'");
3924 }
3925 arg1 = (PLFLT)(val1);
3926 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3927 if (!SWIG_IsOK(ecode2)) {
3928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr1" "', argument " "2"" of type '" "PLFLT""'");
3929 }
3930 arg2 = (PLFLT)(val2);
3931 {
3932 arg5 = marshal_PLcGrid1( swig_obj[2], 0 );
3933 if ( !arg5 )
3934 return NULL;
3935 }
3936 pltr1(arg1,arg2,arg3,arg4,arg5);
3937 resultobj = SWIG_Py_Void();
3938 if (SWIG_IsTmpObj(res3)) {
3939 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
3940 } else {
3941 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
3943 }
3944 if (SWIG_IsTmpObj(res4)) {
3945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
3946 } else {
3947 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
3948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
3949 }
3950 {
3952 }
3953 return resultobj;
3954fail:
3955 {
3957 }
3958 return NULL;
3959}
3960
3961
3962SWIGINTERN PyObject *_wrap_pltr2(PyObject *self, PyObject *args) {
3963 PyObject *resultobj = 0;
3964 PLFLT arg1 ;
3965 PLFLT arg2 ;
3966 PLFLT *arg3 = (PLFLT *) 0 ;
3967 PLFLT *arg4 = (PLFLT *) 0 ;
3968 PLcGrid2 *arg5 = (PLcGrid2 *) 0 ;
3969 double val1 ;
3970 int ecode1 = 0 ;
3971 double val2 ;
3972 int ecode2 = 0 ;
3973 PLFLT temp3 ;
3974 int res3 = SWIG_TMPOBJ ;
3975 PLFLT temp4 ;
3976 int res4 = SWIG_TMPOBJ ;
3977 PyObject *swig_obj[3] ;
3978
3979 arg3 = &temp3;
3980 arg4 = &temp4;
3981 (void)self;
3982 if (!SWIG_Python_UnpackTuple(args, "pltr2", 3, 3, swig_obj)) SWIG_fail;
3983 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
3984 if (!SWIG_IsOK(ecode1)) {
3985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pltr2" "', argument " "1"" of type '" "PLFLT""'");
3986 }
3987 arg1 = (PLFLT)(val1);
3988 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
3989 if (!SWIG_IsOK(ecode2)) {
3990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltr2" "', argument " "2"" of type '" "PLFLT""'");
3991 }
3992 arg2 = (PLFLT)(val2);
3993 {
3994 arg5 = marshal_PLcGrid2( swig_obj[2], 0 );
3995 if ( !arg5 )
3996 return NULL;
3997 }
3998 pltr2(arg1,arg2,arg3,arg4,arg5);
3999 resultobj = SWIG_Py_Void();
4000 if (SWIG_IsTmpObj(res3)) {
4001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
4002 } else {
4003 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
4005 }
4006 if (SWIG_IsTmpObj(res4)) {
4007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
4008 } else {
4009 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
4010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
4011 }
4012 {
4014 }
4015 return resultobj;
4016fail:
4017 {
4019 }
4020 return NULL;
4021}
4022
4023
4024
4025 // helper code for handling the callback
4026#if 0
4027 static PyInterpreterState *save_interp = NULL;
4028#endif
4030 PyObject* python_pltr = NULL;
4031 PyObject* python_f2eval = NULL;
4032 PyObject* python_ct = NULL;
4033 PyObject* python_mapform = NULL;
4034 PyObject* python_label = NULL;
4035
4036#if 0
4037#define MY_BLOCK_THREADS { \
4038 PyThreadState *prev_state, *new_state; \
4039 /* need to have started a thread at some stage */ \
4040 /* for the following to work */ \
4041 PyEval_AcquireLock(); \
4042 new_state = PyThreadState_New( save_interp ); \
4043 prev_state = PyThreadState_Swap( new_state );
4044#define MY_UNBLOCK_THREADS \
4045 new_state = PyThreadState_Swap( prev_state ); \
4046 PyThreadState_Clear( new_state ); \
4047 PyEval_ReleaseLock(); \
4048 PyThreadState_Delete( new_state ); \
4049 }
4050#else
4051#define MY_BLOCK_THREADS
4052#define MY_UNBLOCK_THREADS
4053#endif
4054
4055// Function prototypes
4056 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data );
4058 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data );
4059 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data );
4060 void do_mapform_callback( PLINT n, PLFLT *x, PLFLT *y );
4061 pltr_func marshal_pltr( PyObject* input );
4062 void cleanup_pltr( void );
4063 ct_func marshal_ct( PyObject* input );
4064 void cleanup_ct( void );
4065 mapform_func marshal_mapform( PyObject* input );
4066 void cleanup_mapform( void );
4067 PLPointer marshal_PLPointer( PyObject* input, int isimg );
4068 void cleanup_PLPointer( void );
4069
4070
4071// This is the callback that gets handed to the C code. It, in turn, calls the Python callback
4072
4073 void do_pltr_callback( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data )
4074 {
4075 PyObject *pdata, *arglist, *result;
4076 PyArrayObject *tmp;
4077
4078 // the data argument is acutally a pointer to a python object
4079 pdata = (PyObject *) data;
4080 if ( data == NULL )
4081 {
4082 pdata = Py_None;
4083 }
4084 if ( python_pltr ) // if not something is terribly wrong
4085 { // hold a reference to the data object
4086 Py_XINCREF( pdata );
4087 // grab the Global Interpreter Lock to be sure threads don't mess us up
4089 // build the argument list
4090#ifdef PL_DOUBLE
4091 arglist = Py_BuildValue( "(ddO)", x, y, pdata );
4092#else
4093 arglist = Py_BuildValue( "(ffO)", x, y, pdata );
4094#endif
4095 if ( arglist == NULL )
4096 {
4097 fprintf( stderr, "Py_BuildValue failed to make argument list.\n" );
4098 *tx = *ty = 0;
4099 return;
4100 }
4101 // call the python function
4102 result = PyObject_CallObject( python_pltr, arglist );
4103 // release the argument list
4104 Py_CLEAR( arglist );
4105 // check and unpack the result
4106 if ( result == NULL )
4107 {
4108 fprintf( stderr, "call to python pltr function with 3 arguments failed\n" );
4109 PyErr_SetString( PyExc_RuntimeError, "pltr callback must take 3 arguments." );
4110 *tx = *ty = 0;
4111 }
4112 else
4113 {
4114 tmp = (PyArrayObject *) myArray_ContiguousFromObject( result, NPY_PLFLT, 1, 1 );
4115 if ( tmp == 0 || PyArray_DIMS( tmp )[0] != 2 )
4116 {
4117 fprintf( stderr, "pltr callback must return a 2 element array or sequence\n" );
4118 PyErr_SetString( PyExc_RuntimeError, "pltr callback must return a 2-sequence." );
4119 *tx = *ty = 0;
4120 }
4121 else
4122 {
4123 PLFLT* t = (PLFLT *) PyArray_DATA( tmp );
4124 *tx = t[0];
4125 *ty = t[1];
4126 Py_CLEAR( tmp );
4127 }
4128 }
4129 // release the result
4130 Py_CLEAR( result );
4131 // release the global interpreter lock
4133 }
4134 }
4135
4137 {
4138 PyObject *pdata, *arglist, *result;
4139 PLFLT fresult = 0.0;
4140
4141 // the data argument is acutally a pointer to a python object
4142 pdata = (PyObject *) data;
4143 if ( python_f2eval ) // if not something is terribly wrong
4144 { // hold a reference to the data object
4145 Py_XINCREF( pdata );
4146 // grab the Global Interpreter Lock to be sure threads don't mess us up
4148 // build the argument list
4149 arglist = Py_BuildValue( "(iiO)", x, y, pdata );
4150 // call the python function
4151 result = PyObject_CallObject( python_f2eval, arglist );
4152 // release the argument list
4153 Py_CLEAR( arglist );
4154 // check and unpack the result
4155 if ( !PyFloat_Check( result ) )
4156 {
4157 fprintf( stderr, "f2eval callback must return a float\n" );
4158 PyErr_SetString( PyExc_RuntimeError, "f2eval callback must return a float." );
4159 }
4160 else
4161 {
4162 // should I test the type here?
4163 fresult = (PLFLT) PyFloat_AsDouble( result );
4164 }
4165 // release the result
4166 Py_CLEAR( result );
4167 // release the global interpreter lock
4169 }
4170 return fresult;
4171 }
4172
4173 void do_label_callback( PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data )
4174 {
4175 PyObject *pdata, *arglist, *result, *unicode_string;
4176 char *pystring;
4177
4178 // the data argument is acutally a pointer to a python object
4179 if ( data )
4180 pdata = (PyObject *) data;
4181 else
4182 pdata = Py_None;
4183 if ( python_label ) // if not something is terribly wrong
4184 { // hold a reference to the data object
4185 Py_XINCREF( pdata );
4186 // grab the Global Interpreter Lock to be sure threads don't mess us up
4188 // build the argument list
4189#ifdef PL_DOUBLE
4190 arglist = Py_BuildValue( "(ldO)", axis, value, pdata );
4191#else
4192 arglist = Py_BuildValue( "(lfO)", axis, value, pdata );
4193#endif
4194 // call the python function
4195 result = PyObject_CallObject( python_label, arglist );
4196 // release the argument list
4197 //Py_CLEAR(arglist);
4198 // check and unpack the result
4199 if ( result == NULL )
4200 {
4201 fprintf( stderr, "label callback failed with 3 arguments\n" );
4202 PyErr_SetString( PyExc_RuntimeError, "label callback must take 3 arguments." );
4203 }
4204 else if ( PyString_Check( result ) )
4205 {
4206 // should I test the type here?
4207 pystring = PyString_AsString( result );
4208 strncpy( string, pystring, len );
4209 }
4210 else if ( PyUnicode_Check( result ) )
4211 {
4212 // unicode_string is never freed? memory leak here?
4213 unicode_string = PyUnicode_AsEncodedString( result, "utf-8", "Error ~" );
4214 pystring = PyBytes_AS_STRING( unicode_string );
4215 // len may be different then the byte string length w/ unicode?
4216 strncpy( string, pystring, len );
4217 }
4218 else
4219 {
4220 fprintf( stderr, "label callback must return a string\n" );
4221 PyErr_SetString( PyExc_RuntimeError, "label callback must return a string." );
4222 }
4223 // release the result
4224 Py_CLEAR( result );
4225 // release the global interpreter lock
4227 }
4228 }
4229
4230 void do_ct_callback( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
4231 {
4232 PyObject *px, *py, *pdata, *arglist, *result;
4233 npy_intp n;
4234 n = 1;
4235
4236 // the data argument is acutally a pointer to a python object
4237 pdata = (PyObject *) data;
4238 if ( data == NULL )
4239 {
4240 pdata = Py_None;
4241 }
4242 if ( python_ct ) // if not something is terribly wrong
4243 { // hold a reference to the data object
4244 Py_XINCREF( pdata );
4245 // grab the Global Interpreter Lock to be sure threads don't mess us up
4247 // build the argument list
4248 px = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) xt );
4249 py = PyArray_SimpleNewFromData( 1, &n, NPY_PLFLT, (void *) yt );
4250 arglist = Py_BuildValue( "(ddOOO)", x, y, px, py, pdata );
4251 // call the python function
4252 result = PyObject_CallObject( python_ct, arglist );
4253 // release the argument list
4254 Py_CLEAR( arglist );
4255 Py_CLEAR( px );
4256 Py_CLEAR( py );
4257 Py_CLEAR( pdata );
4258 // check and unpack the result
4259 if ( result == NULL )
4260 {
4261 fprintf( stderr, "call to python coordinate transform function with 5 arguments failed\n" );
4262 PyErr_SetString( PyExc_RuntimeError, "coordinate transform callback must take 5 arguments." );
4263 }
4264 // release the result
4265 Py_CLEAR( result );
4266 // release the global interpreter lock
4268 }
4269 }
4270
4272 {
4273 PyObject *px, *py, *arglist, *result;
4274 // PyArrayObject *tmpx, *tmpy;
4275// PLFLT *xx, *yy;
4276// PLINT i;
4277 npy_intp nn;
4278 nn = n;
4279
4280 if ( python_mapform ) // if not something is terribly wrong
4281 { // grab the Global Interpreter Lock to be sure threads don't mess us up
4283 // build the argument list
4284#ifdef PL_HAVE_PTHREAD
4285 px = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) x );
4286 py = PyArray_SimpleNewFromData( 1, &nn, NPY_PLFLT, (void *) y );
4287#else
4288 px = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) x );
4289 py = PyArray_FromDimsAndData( 1, &n, NPY_PLFLT, (char *) y );
4290#endif
4291 arglist = Py_BuildValue( "(iOO)", n, px, py );
4292 // call the python function
4293 result = PyObject_CallObject( python_mapform, arglist );
4294 // release the argument list
4295 Py_CLEAR( arglist );
4296 Py_CLEAR( px );
4297 Py_CLEAR( py );
4298 // check and unpack the result
4299 if ( result == NULL )
4300 {
4301 fprintf( stderr, "call to python mapform function with 3 arguments failed\n" );
4302 PyErr_SetString( PyExc_RuntimeError, "mapform callback must take 3 arguments." );
4303 }
4304 // release the result
4305 Py_CLEAR( result );
4306 // release the global interpreter lock
4308 }
4309 }
4310
4311// marshal the pltr function pointer argument
4312 pltr_func marshal_pltr( PyObject* input )
4313 {
4314 pltr_func result = do_pltr_callback;
4315 PyObject * rep = PyObject_Repr( input );
4316 if ( rep )
4317 {
4318 // Memory leaks here? str and uni_str are not freed?
4319 char* str;
4320 if ( PyUnicode_Check( rep ) )
4321 {
4322 PyObject *uni_str = PyUnicode_AsEncodedString( rep, "utf-8", "Error ~" );
4323 str = PyBytes_AS_STRING( uni_str );
4324 }
4325 else
4326 {
4327 str = PyString_AsString( rep );
4328 }
4329 if ( strstr( str, "function pltr0" ) != 0 )
4330 {
4331 result = pltr0;
4332 pltr_type = CB_0;
4333 python_pltr = NULL;
4334 }
4335 else if ( strstr( str, "function pltr1" ) != 0 )
4336 {
4337 result = pltr1;
4338 pltr_type = CB_1;
4339 python_pltr = NULL;
4340 }
4341 else if ( strstr( str, "function pltr2" ) != 0 )
4342 {
4343 result = pltr2;
4344 pltr_type = CB_2;
4345 python_pltr = NULL;
4346 }
4347 else
4348 {
4349 python_pltr = input;
4351 Py_XINCREF( input );
4352 }
4353 Py_CLEAR( rep );
4354 }
4355 else
4356 {
4357 python_pltr = input;
4359 Py_XINCREF( input );
4360 }
4361 return result;
4362 }
4363
4364 void cleanup_pltr( void )
4365 {
4366 Py_CLEAR( python_pltr );
4367 python_pltr = 0;
4368 }
4369
4370// marshal the ct function pointer argument
4371 ct_func marshal_ct( PyObject* input )
4372 {
4373 ct_func result = do_ct_callback;
4374 python_ct = input;
4375 Py_XINCREF( input );
4376 return result;
4377 }
4378
4379 void cleanup_ct( void )
4380 {
4381 Py_CLEAR( python_ct );
4382 python_ct = 0;
4383 }
4384
4385// marshal the mapform function pointer argument
4387 {
4389 python_mapform = input;
4390 Py_XINCREF( input );
4391 return result;
4392 }
4393
4394 void cleanup_mapform( void )
4395 {
4396 Py_CLEAR( python_mapform );
4397 python_mapform = 0;
4398 }
4399
4400 PLPointer marshal_PLPointer( PyObject* input, int isimg )
4401 {
4402 PLPointer result = NULL;
4403 switch ( pltr_type )
4404 {
4405 case CB_0:
4406 break;
4407 case CB_1:
4408 if ( input != Py_None )
4409 result = marshal_PLcGrid1( input, isimg );
4410 break;
4411 case CB_2:
4412 if ( input != Py_None )
4413 result = marshal_PLcGrid2( input, isimg );
4414 break;
4415 case CB_Python:
4416 Py_XINCREF( input );
4417 result = (PLPointer *) input;
4418 break;
4419 default:
4420 fprintf( stderr, "pltr_type is invalid\n" );
4421 }
4422 return result;
4423 }
4424
4426 {
4427 switch ( pltr_type )
4428 {
4429 case CB_0:
4430 break;
4431 case CB_1:
4433 break;
4434 case CB_2:
4436 break;
4437 case CB_Python:
4438 Py_CLEAR( python_pltr );
4439 break;
4440 default:
4441 fprintf( stderr, "pltr_type is invalid\n" );
4442 }
4443 python_pltr = 0;
4444 pltr_type = CB_0;
4445 }
4446
4447
4448
4449SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args) {
4450 PyObject *resultobj = 0;
4451 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4452 int arg2 ;
4453 void *argp1 = 0 ;
4454 int res1 = 0 ;
4455 int val2 ;
4456 int ecode2 = 0 ;
4457 PyObject *swig_obj[2] ;
4458
4459 (void)self;
4460 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_type_set", 2, 2, swig_obj)) SWIG_fail;
4461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4462 if (!SWIG_IsOK(res1)) {
4463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4464 }
4465 arg1 = (PLGraphicsIn *)(argp1);
4466 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4467 if (!SWIG_IsOK(ecode2)) {
4468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
4469 }
4470 arg2 = (int)(val2);
4471 if (arg1) (arg1)->type = arg2;
4472 resultobj = SWIG_Py_Void();
4473 return resultobj;
4474fail:
4475 return NULL;
4476}
4477
4478
4479SWIGINTERN PyObject *_wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args) {
4480 PyObject *resultobj = 0;
4481 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4482 void *argp1 = 0 ;
4483 int res1 = 0 ;
4484 PyObject *swig_obj[1] ;
4485 int result;
4486
4487 (void)self;
4488 if (!args) SWIG_fail;
4489 swig_obj[0] = args;
4490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4491 if (!SWIG_IsOK(res1)) {
4492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4493 }
4494 arg1 = (PLGraphicsIn *)(argp1);
4495 result = (int) ((arg1)->type);
4496 resultobj = SWIG_From_int((int)(result));
4497 return resultobj;
4498fail:
4499 return NULL;
4500}
4501
4502
4503SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args) {
4504 PyObject *resultobj = 0;
4505 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4506 unsigned int arg2 ;
4507 void *argp1 = 0 ;
4508 int res1 = 0 ;
4509 unsigned int val2 ;
4510 int ecode2 = 0 ;
4511 PyObject *swig_obj[2] ;
4512
4513 (void)self;
4514 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_state_set", 2, 2, swig_obj)) SWIG_fail;
4515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4516 if (!SWIG_IsOK(res1)) {
4517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4518 }
4519 arg1 = (PLGraphicsIn *)(argp1);
4520 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4521 if (!SWIG_IsOK(ecode2)) {
4522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
4523 }
4524 arg2 = (unsigned int)(val2);
4525 if (arg1) (arg1)->state = arg2;
4526 resultobj = SWIG_Py_Void();
4527 return resultobj;
4528fail:
4529 return NULL;
4530}
4531
4532
4533SWIGINTERN PyObject *_wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args) {
4534 PyObject *resultobj = 0;
4535 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4536 void *argp1 = 0 ;
4537 int res1 = 0 ;
4538 PyObject *swig_obj[1] ;
4539 unsigned int result;
4540
4541 (void)self;
4542 if (!args) SWIG_fail;
4543 swig_obj[0] = args;
4544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4545 if (!SWIG_IsOK(res1)) {
4546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4547 }
4548 arg1 = (PLGraphicsIn *)(argp1);
4549 result = (unsigned int) ((arg1)->state);
4550 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4551 return resultobj;
4552fail:
4553 return NULL;
4554}
4555
4556
4557SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args) {
4558 PyObject *resultobj = 0;
4559 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4560 unsigned int arg2 ;
4561 void *argp1 = 0 ;
4562 int res1 = 0 ;
4563 unsigned int val2 ;
4564 int ecode2 = 0 ;
4565 PyObject *swig_obj[2] ;
4566
4567 (void)self;
4568 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_keysym_set", 2, 2, swig_obj)) SWIG_fail;
4569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4570 if (!SWIG_IsOK(res1)) {
4571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4572 }
4573 arg1 = (PLGraphicsIn *)(argp1);
4574 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4575 if (!SWIG_IsOK(ecode2)) {
4576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
4577 }
4578 arg2 = (unsigned int)(val2);
4579 if (arg1) (arg1)->keysym = arg2;
4580 resultobj = SWIG_Py_Void();
4581 return resultobj;
4582fail:
4583 return NULL;
4584}
4585
4586
4587SWIGINTERN PyObject *_wrap_PLGraphicsIn_keysym_get(PyObject *self, PyObject *args) {
4588 PyObject *resultobj = 0;
4589 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4590 void *argp1 = 0 ;
4591 int res1 = 0 ;
4592 PyObject *swig_obj[1] ;
4593 unsigned int result;
4594
4595 (void)self;
4596 if (!args) SWIG_fail;
4597 swig_obj[0] = args;
4598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4599 if (!SWIG_IsOK(res1)) {
4600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4601 }
4602 arg1 = (PLGraphicsIn *)(argp1);
4603 result = (unsigned int) ((arg1)->keysym);
4604 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4605 return resultobj;
4606fail:
4607 return NULL;
4608}
4609
4610
4611SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args) {
4612 PyObject *resultobj = 0;
4613 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4614 unsigned int arg2 ;
4615 void *argp1 = 0 ;
4616 int res1 = 0 ;
4617 unsigned int val2 ;
4618 int ecode2 = 0 ;
4619 PyObject *swig_obj[2] ;
4620
4621 (void)self;
4622 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_button_set", 2, 2, swig_obj)) SWIG_fail;
4623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4624 if (!SWIG_IsOK(res1)) {
4625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4626 }
4627 arg1 = (PLGraphicsIn *)(argp1);
4628 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
4629 if (!SWIG_IsOK(ecode2)) {
4630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
4631 }
4632 arg2 = (unsigned int)(val2);
4633 if (arg1) (arg1)->button = arg2;
4634 resultobj = SWIG_Py_Void();
4635 return resultobj;
4636fail:
4637 return NULL;
4638}
4639
4640
4641SWIGINTERN PyObject *_wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args) {
4642 PyObject *resultobj = 0;
4643 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4644 void *argp1 = 0 ;
4645 int res1 = 0 ;
4646 PyObject *swig_obj[1] ;
4647 unsigned int result;
4648
4649 (void)self;
4650 if (!args) SWIG_fail;
4651 swig_obj[0] = args;
4652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4653 if (!SWIG_IsOK(res1)) {
4654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4655 }
4656 arg1 = (PLGraphicsIn *)(argp1);
4657 result = (unsigned int) ((arg1)->button);
4658 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4659 return resultobj;
4660fail:
4661 return NULL;
4662}
4663
4664
4665SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args) {
4666 PyObject *resultobj = 0;
4667 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4668 PLINT arg2 ;
4669 void *argp1 = 0 ;
4670 int res1 = 0 ;
4671 int val2 ;
4672 int ecode2 = 0 ;
4673 PyObject *swig_obj[2] ;
4674
4675 (void)self;
4676 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_subwindow_set", 2, 2, swig_obj)) SWIG_fail;
4677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4678 if (!SWIG_IsOK(res1)) {
4679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4680 }
4681 arg1 = (PLGraphicsIn *)(argp1);
4682 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4683 if (!SWIG_IsOK(ecode2)) {
4684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
4685 }
4686 arg2 = (PLINT)(val2);
4687 if (arg1) (arg1)->subwindow = arg2;
4688 resultobj = SWIG_Py_Void();
4689 return resultobj;
4690fail:
4691 return NULL;
4692}
4693
4694
4695SWIGINTERN PyObject *_wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args) {
4696 PyObject *resultobj = 0;
4697 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4698 void *argp1 = 0 ;
4699 int res1 = 0 ;
4700 PyObject *swig_obj[1] ;
4701 PLINT result;
4702
4703 (void)self;
4704 if (!args) SWIG_fail;
4705 swig_obj[0] = args;
4706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4707 if (!SWIG_IsOK(res1)) {
4708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4709 }
4710 arg1 = (PLGraphicsIn *)(argp1);
4711 result = (PLINT) ((arg1)->subwindow);
4712 resultobj = SWIG_From_int((int)(result));
4713 return resultobj;
4714fail:
4715 return NULL;
4716}
4717
4718
4719SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_set(PyObject *self, PyObject *args) {
4720 PyObject *resultobj = 0;
4721 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4722 char *arg2 = (char *) (char *)0 ;
4723 void *argp1 = 0 ;
4724 int res1 = 0 ;
4725 char temp2[16] ;
4726 int res2 ;
4727 PyObject *swig_obj[2] ;
4728
4729 (void)self;
4730 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_string_set", 2, 2, swig_obj)) SWIG_fail;
4731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4732 if (!SWIG_IsOK(res1)) {
4733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4734 }
4735 arg1 = (PLGraphicsIn *)(argp1);
4736 res2 = SWIG_AsCharArray(swig_obj[1], temp2, 16);
4737 if (!SWIG_IsOK(res2)) {
4738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
4739 }
4740 arg2 = (char *)(temp2);
4741 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
4742 else memset(arg1->string,0,16*sizeof(char));
4743 resultobj = SWIG_Py_Void();
4744 return resultobj;
4745fail:
4746 return NULL;
4747}
4748
4749
4750SWIGINTERN PyObject *_wrap_PLGraphicsIn_string_get(PyObject *self, PyObject *args) {
4751 PyObject *resultobj = 0;
4752 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4753 void *argp1 = 0 ;
4754 int res1 = 0 ;
4755 PyObject *swig_obj[1] ;
4756 char *result = 0 ;
4757
4758 (void)self;
4759 if (!args) SWIG_fail;
4760 swig_obj[0] = args;
4761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4762 if (!SWIG_IsOK(res1)) {
4763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4764 }
4765 arg1 = (PLGraphicsIn *)(argp1);
4766 result = (char *)(char *) ((arg1)->string);
4767 {
4768 size_t size = SWIG_strnlen(result, 16);
4769
4770
4771
4772 resultobj = SWIG_FromCharPtrAndSize(result, size);
4773 }
4774 return resultobj;
4775fail:
4776 return NULL;
4777}
4778
4779
4780SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args) {
4781 PyObject *resultobj = 0;
4782 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4783 int arg2 ;
4784 void *argp1 = 0 ;
4785 int res1 = 0 ;
4786 int val2 ;
4787 int ecode2 = 0 ;
4788 PyObject *swig_obj[2] ;
4789
4790 (void)self;
4791 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pX_set", 2, 2, swig_obj)) SWIG_fail;
4792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4793 if (!SWIG_IsOK(res1)) {
4794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4795 }
4796 arg1 = (PLGraphicsIn *)(argp1);
4797 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4798 if (!SWIG_IsOK(ecode2)) {
4799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
4800 }
4801 arg2 = (int)(val2);
4802 if (arg1) (arg1)->pX = arg2;
4803 resultobj = SWIG_Py_Void();
4804 return resultobj;
4805fail:
4806 return NULL;
4807}
4808
4809
4810SWIGINTERN PyObject *_wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args) {
4811 PyObject *resultobj = 0;
4812 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4813 void *argp1 = 0 ;
4814 int res1 = 0 ;
4815 PyObject *swig_obj[1] ;
4816 int result;
4817
4818 (void)self;
4819 if (!args) SWIG_fail;
4820 swig_obj[0] = args;
4821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4822 if (!SWIG_IsOK(res1)) {
4823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4824 }
4825 arg1 = (PLGraphicsIn *)(argp1);
4826 result = (int) ((arg1)->pX);
4827 resultobj = SWIG_From_int((int)(result));
4828 return resultobj;
4829fail:
4830 return NULL;
4831}
4832
4833
4834SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args) {
4835 PyObject *resultobj = 0;
4836 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4837 int arg2 ;
4838 void *argp1 = 0 ;
4839 int res1 = 0 ;
4840 int val2 ;
4841 int ecode2 = 0 ;
4842 PyObject *swig_obj[2] ;
4843
4844 (void)self;
4845 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_pY_set", 2, 2, swig_obj)) SWIG_fail;
4846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4847 if (!SWIG_IsOK(res1)) {
4848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4849 }
4850 arg1 = (PLGraphicsIn *)(argp1);
4851 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4852 if (!SWIG_IsOK(ecode2)) {
4853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
4854 }
4855 arg2 = (int)(val2);
4856 if (arg1) (arg1)->pY = arg2;
4857 resultobj = SWIG_Py_Void();
4858 return resultobj;
4859fail:
4860 return NULL;
4861}
4862
4863
4864SWIGINTERN PyObject *_wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args) {
4865 PyObject *resultobj = 0;
4866 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4867 void *argp1 = 0 ;
4868 int res1 = 0 ;
4869 PyObject *swig_obj[1] ;
4870 int result;
4871
4872 (void)self;
4873 if (!args) SWIG_fail;
4874 swig_obj[0] = args;
4875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4876 if (!SWIG_IsOK(res1)) {
4877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4878 }
4879 arg1 = (PLGraphicsIn *)(argp1);
4880 result = (int) ((arg1)->pY);
4881 resultobj = SWIG_From_int((int)(result));
4882 return resultobj;
4883fail:
4884 return NULL;
4885}
4886
4887
4888SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args) {
4889 PyObject *resultobj = 0;
4890 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4891 PLFLT arg2 ;
4892 void *argp1 = 0 ;
4893 int res1 = 0 ;
4894 double val2 ;
4895 int ecode2 = 0 ;
4896 PyObject *swig_obj[2] ;
4897
4898 (void)self;
4899 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dX_set", 2, 2, swig_obj)) SWIG_fail;
4900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4901 if (!SWIG_IsOK(res1)) {
4902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4903 }
4904 arg1 = (PLGraphicsIn *)(argp1);
4905 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4906 if (!SWIG_IsOK(ecode2)) {
4907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
4908 }
4909 arg2 = (PLFLT)(val2);
4910 if (arg1) (arg1)->dX = arg2;
4911 resultobj = SWIG_Py_Void();
4912 return resultobj;
4913fail:
4914 return NULL;
4915}
4916
4917
4918SWIGINTERN PyObject *_wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args) {
4919 PyObject *resultobj = 0;
4920 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4921 void *argp1 = 0 ;
4922 int res1 = 0 ;
4923 PyObject *swig_obj[1] ;
4924 PLFLT result;
4925
4926 (void)self;
4927 if (!args) SWIG_fail;
4928 swig_obj[0] = args;
4929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4930 if (!SWIG_IsOK(res1)) {
4931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4932 }
4933 arg1 = (PLGraphicsIn *)(argp1);
4934 result = (PLFLT) ((arg1)->dX);
4935 resultobj = SWIG_From_double((double)(result));
4936 return resultobj;
4937fail:
4938 return NULL;
4939}
4940
4941
4942SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args) {
4943 PyObject *resultobj = 0;
4944 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4945 PLFLT arg2 ;
4946 void *argp1 = 0 ;
4947 int res1 = 0 ;
4948 double val2 ;
4949 int ecode2 = 0 ;
4950 PyObject *swig_obj[2] ;
4951
4952 (void)self;
4953 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_dY_set", 2, 2, swig_obj)) SWIG_fail;
4954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4955 if (!SWIG_IsOK(res1)) {
4956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4957 }
4958 arg1 = (PLGraphicsIn *)(argp1);
4959 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
4960 if (!SWIG_IsOK(ecode2)) {
4961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
4962 }
4963 arg2 = (PLFLT)(val2);
4964 if (arg1) (arg1)->dY = arg2;
4965 resultobj = SWIG_Py_Void();
4966 return resultobj;
4967fail:
4968 return NULL;
4969}
4970
4971
4972SWIGINTERN PyObject *_wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args) {
4973 PyObject *resultobj = 0;
4974 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4975 void *argp1 = 0 ;
4976 int res1 = 0 ;
4977 PyObject *swig_obj[1] ;
4978 PLFLT result;
4979
4980 (void)self;
4981 if (!args) SWIG_fail;
4982 swig_obj[0] = args;
4983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
4984 if (!SWIG_IsOK(res1)) {
4985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
4986 }
4987 arg1 = (PLGraphicsIn *)(argp1);
4988 result = (PLFLT) ((arg1)->dY);
4989 resultobj = SWIG_From_double((double)(result));
4990 return resultobj;
4991fail:
4992 return NULL;
4993}
4994
4995
4996SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args) {
4997 PyObject *resultobj = 0;
4998 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
4999 PLFLT arg2 ;
5000 void *argp1 = 0 ;
5001 int res1 = 0 ;
5002 double val2 ;
5003 int ecode2 = 0 ;
5004 PyObject *swig_obj[2] ;
5005
5006 (void)self;
5007 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wX_set", 2, 2, swig_obj)) SWIG_fail;
5008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5009 if (!SWIG_IsOK(res1)) {
5010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5011 }
5012 arg1 = (PLGraphicsIn *)(argp1);
5013 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5014 if (!SWIG_IsOK(ecode2)) {
5015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
5016 }
5017 arg2 = (PLFLT)(val2);
5018 if (arg1) (arg1)->wX = arg2;
5019 resultobj = SWIG_Py_Void();
5020 return resultobj;
5021fail:
5022 return NULL;
5023}
5024
5025
5026SWIGINTERN PyObject *_wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args) {
5027 PyObject *resultobj = 0;
5028 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5029 void *argp1 = 0 ;
5030 int res1 = 0 ;
5031 PyObject *swig_obj[1] ;
5032 PLFLT result;
5033
5034 (void)self;
5035 if (!args) SWIG_fail;
5036 swig_obj[0] = args;
5037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5038 if (!SWIG_IsOK(res1)) {
5039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5040 }
5041 arg1 = (PLGraphicsIn *)(argp1);
5042 result = (PLFLT) ((arg1)->wX);
5043 resultobj = SWIG_From_double((double)(result));
5044 return resultobj;
5045fail:
5046 return NULL;
5047}
5048
5049
5050SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args) {
5051 PyObject *resultobj = 0;
5052 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5053 PLFLT arg2 ;
5054 void *argp1 = 0 ;
5055 int res1 = 0 ;
5056 double val2 ;
5057 int ecode2 = 0 ;
5058 PyObject *swig_obj[2] ;
5059
5060 (void)self;
5061 if (!SWIG_Python_UnpackTuple(args, "PLGraphicsIn_wY_set", 2, 2, swig_obj)) SWIG_fail;
5062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5063 if (!SWIG_IsOK(res1)) {
5064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5065 }
5066 arg1 = (PLGraphicsIn *)(argp1);
5067 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5068 if (!SWIG_IsOK(ecode2)) {
5069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
5070 }
5071 arg2 = (PLFLT)(val2);
5072 if (arg1) (arg1)->wY = arg2;
5073 resultobj = SWIG_Py_Void();
5074 return resultobj;
5075fail:
5076 return NULL;
5077}
5078
5079
5080SWIGINTERN PyObject *_wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args) {
5081 PyObject *resultobj = 0;
5082 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5083 void *argp1 = 0 ;
5084 int res1 = 0 ;
5085 PyObject *swig_obj[1] ;
5086 PLFLT result;
5087
5088 (void)self;
5089 if (!args) SWIG_fail;
5090 swig_obj[0] = args;
5091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
5092 if (!SWIG_IsOK(res1)) {
5093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5094 }
5095 arg1 = (PLGraphicsIn *)(argp1);
5096 result = (PLFLT) ((arg1)->wY);
5097 resultobj = SWIG_From_double((double)(result));
5098 return resultobj;
5099fail:
5100 return NULL;
5101}
5102
5103
5104SWIGINTERN PyObject *_wrap_new_PLGraphicsIn(PyObject *self, PyObject *args) {
5105 PyObject *resultobj = 0;
5106 PLGraphicsIn *result = 0 ;
5107
5108 (void)self;
5109 if (!SWIG_Python_UnpackTuple(args, "new_PLGraphicsIn", 0, 0, 0)) SWIG_fail;
5110 result = (PLGraphicsIn *)calloc(1, sizeof(PLGraphicsIn));
5112 return resultobj;
5113fail:
5114 return NULL;
5115}
5116
5117
5118SWIGINTERN PyObject *_wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args) {
5119 PyObject *resultobj = 0;
5120 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
5121 void *argp1 = 0 ;
5122 int res1 = 0 ;
5123 PyObject *swig_obj[1] ;
5124
5125 (void)self;
5126 if (!args) SWIG_fail;
5127 swig_obj[0] = args;
5128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
5129 if (!SWIG_IsOK(res1)) {
5130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
5131 }
5132 arg1 = (PLGraphicsIn *)(argp1);
5133 free((char *) arg1);
5134 resultobj = SWIG_Py_Void();
5135 return resultobj;
5136fail:
5137 return NULL;
5138}
5139
5140
5141SWIGINTERN PyObject *PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5142 PyObject *obj = NULL;
5143 if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
5145 return SWIG_Py_Void();
5146}
5147
5148SWIGINTERN PyObject *PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149 return SWIG_Python_InitShadowInstance(args);
5150}
5151
5152SWIGINTERN PyObject *_wrap_plsxwin(PyObject *self, PyObject *args) {
5153 PyObject *resultobj = 0;
5154 PLINT arg1 ;
5155 int val1 ;
5156 int ecode1 = 0 ;
5157 PyObject *swig_obj[1] ;
5158
5159 (void)self;
5160 if (!args) SWIG_fail;
5161 swig_obj[0] = args;
5162 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5163 if (!SWIG_IsOK(ecode1)) {
5164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxwin" "', argument " "1"" of type '" "PLINT""'");
5165 }
5166 arg1 = (PLINT)(val1);
5167 plsxwin(arg1);
5168 resultobj = SWIG_Py_Void();
5169 return resultobj;
5170fail:
5171 return NULL;
5172}
5173
5174
5175SWIGINTERN PyObject *_wrap_pl_setcontlabelformat(PyObject *self, PyObject *args) {
5176 PyObject *resultobj = 0;
5177 PLINT arg1 ;
5178 PLINT arg2 ;
5179 int val1 ;
5180 int ecode1 = 0 ;
5181 int val2 ;
5182 int ecode2 = 0 ;
5183 PyObject *swig_obj[2] ;
5184
5185 (void)self;
5186 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelformat", 2, 2, swig_obj)) SWIG_fail;
5187 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5188 if (!SWIG_IsOK(ecode1)) {
5189 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
5190 }
5191 arg1 = (PLINT)(val1);
5192 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5193 if (!SWIG_IsOK(ecode2)) {
5194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
5195 }
5196 arg2 = (PLINT)(val2);
5197 pl_setcontlabelformat(arg1,arg2);
5198 resultobj = SWIG_Py_Void();
5199 return resultobj;
5200fail:
5201 return NULL;
5202}
5203
5204
5205SWIGINTERN PyObject *_wrap_pl_setcontlabelparam(PyObject *self, PyObject *args) {
5206 PyObject *resultobj = 0;
5207 PLFLT arg1 ;
5208 PLFLT arg2 ;
5209 PLFLT arg3 ;
5210 PLINT arg4 ;
5211 double val1 ;
5212 int ecode1 = 0 ;
5213 double val2 ;
5214 int ecode2 = 0 ;
5215 double val3 ;
5216 int ecode3 = 0 ;
5217 int val4 ;
5218 int ecode4 = 0 ;
5219 PyObject *swig_obj[4] ;
5220
5221 (void)self;
5222 if (!SWIG_Python_UnpackTuple(args, "pl_setcontlabelparam", 4, 4, swig_obj)) SWIG_fail;
5223 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5224 if (!SWIG_IsOK(ecode1)) {
5225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
5226 }
5227 arg1 = (PLFLT)(val1);
5228 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5229 if (!SWIG_IsOK(ecode2)) {
5230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
5231 }
5232 arg2 = (PLFLT)(val2);
5233 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5234 if (!SWIG_IsOK(ecode3)) {
5235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
5236 }
5237 arg3 = (PLFLT)(val3);
5238 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5239 if (!SWIG_IsOK(ecode4)) {
5240 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
5241 }
5242 arg4 = (PLINT)(val4);
5243 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
5244 resultobj = SWIG_Py_Void();
5245 return resultobj;
5246fail:
5247 return NULL;
5248}
5249
5250
5251SWIGINTERN PyObject *_wrap_pladv(PyObject *self, PyObject *args) {
5252 PyObject *resultobj = 0;
5253 PLINT arg1 ;
5254 int val1 ;
5255 int ecode1 = 0 ;
5256 PyObject *swig_obj[1] ;
5257
5258 (void)self;
5259 if (!args) SWIG_fail;
5260 swig_obj[0] = args;
5261 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5262 if (!SWIG_IsOK(ecode1)) {
5263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
5264 }
5265 arg1 = (PLINT)(val1);
5266 pladv(arg1);
5267 resultobj = SWIG_Py_Void();
5268 return resultobj;
5269fail:
5270 return NULL;
5271}
5272
5273
5274SWIGINTERN PyObject *_wrap_plarc(PyObject *self, PyObject *args) {
5275 PyObject *resultobj = 0;
5276 PLFLT arg1 ;
5277 PLFLT arg2 ;
5278 PLFLT arg3 ;
5279 PLFLT arg4 ;
5280 PLFLT arg5 ;
5281 PLFLT arg6 ;
5282 PLFLT arg7 ;
5283 PLBOOL arg8 ;
5284 double val1 ;
5285 int ecode1 = 0 ;
5286 double val2 ;
5287 int ecode2 = 0 ;
5288 double val3 ;
5289 int ecode3 = 0 ;
5290 double val4 ;
5291 int ecode4 = 0 ;
5292 double val5 ;
5293 int ecode5 = 0 ;
5294 double val6 ;
5295 int ecode6 = 0 ;
5296 double val7 ;
5297 int ecode7 = 0 ;
5298 int val8 ;
5299 int ecode8 = 0 ;
5300 PyObject *swig_obj[8] ;
5301
5302 (void)self;
5303 if (!SWIG_Python_UnpackTuple(args, "plarc", 8, 8, swig_obj)) SWIG_fail;
5304 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5305 if (!SWIG_IsOK(ecode1)) {
5306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
5307 }
5308 arg1 = (PLFLT)(val1);
5309 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5310 if (!SWIG_IsOK(ecode2)) {
5311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
5312 }
5313 arg2 = (PLFLT)(val2);
5314 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5315 if (!SWIG_IsOK(ecode3)) {
5316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
5317 }
5318 arg3 = (PLFLT)(val3);
5319 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5320 if (!SWIG_IsOK(ecode4)) {
5321 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
5322 }
5323 arg4 = (PLFLT)(val4);
5324 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5325 if (!SWIG_IsOK(ecode5)) {
5326 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
5327 }
5328 arg5 = (PLFLT)(val5);
5329 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
5330 if (!SWIG_IsOK(ecode6)) {
5331 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
5332 }
5333 arg6 = (PLFLT)(val6);
5334 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5335 if (!SWIG_IsOK(ecode7)) {
5336 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
5337 }
5338 arg7 = (PLFLT)(val7);
5339 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5340 if (!SWIG_IsOK(ecode8)) {
5341 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
5342 }
5343 arg8 = (PLBOOL)(val8);
5344 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5345 resultobj = SWIG_Py_Void();
5346 return resultobj;
5347fail:
5348 return NULL;
5349}
5350
5351
5352SWIGINTERN PyObject *_wrap_plaxes(PyObject *self, PyObject *args) {
5353 PyObject *resultobj = 0;
5354 PLFLT arg1 ;
5355 PLFLT arg2 ;
5356 char *arg3 = (char *) 0 ;
5357 PLFLT arg4 ;
5358 PLINT arg5 ;
5359 char *arg6 = (char *) 0 ;
5360 PLFLT arg7 ;
5361 PLINT arg8 ;
5362 double val1 ;
5363 int ecode1 = 0 ;
5364 double val2 ;
5365 int ecode2 = 0 ;
5366 int res3 ;
5367 char *buf3 = 0 ;
5368 int alloc3 = 0 ;
5369 double val4 ;
5370 int ecode4 = 0 ;
5371 int val5 ;
5372 int ecode5 = 0 ;
5373 int res6 ;
5374 char *buf6 = 0 ;
5375 int alloc6 = 0 ;
5376 double val7 ;
5377 int ecode7 = 0 ;
5378 int val8 ;
5379 int ecode8 = 0 ;
5380 PyObject *swig_obj[8] ;
5381
5382 (void)self;
5383 if (!SWIG_Python_UnpackTuple(args, "plaxes", 8, 8, swig_obj)) SWIG_fail;
5384 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5385 if (!SWIG_IsOK(ecode1)) {
5386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
5387 }
5388 arg1 = (PLFLT)(val1);
5389 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5390 if (!SWIG_IsOK(ecode2)) {
5391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
5392 }
5393 arg2 = (PLFLT)(val2);
5394 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
5395 if (!SWIG_IsOK(res3)) {
5396 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
5397 }
5398 arg3 = (char *)(buf3);
5399 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
5400 if (!SWIG_IsOK(ecode4)) {
5401 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
5402 }
5403 arg4 = (PLFLT)(val4);
5404 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5405 if (!SWIG_IsOK(ecode5)) {
5406 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
5407 }
5408 arg5 = (PLINT)(val5);
5409 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5410 if (!SWIG_IsOK(res6)) {
5411 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
5412 }
5413 arg6 = (char *)(buf6);
5414 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5415 if (!SWIG_IsOK(ecode7)) {
5416 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
5417 }
5418 arg7 = (PLFLT)(val7);
5419 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5420 if (!SWIG_IsOK(ecode8)) {
5421 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
5422 }
5423 arg8 = (PLINT)(val8);
5424 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
5425 resultobj = SWIG_Py_Void();
5426 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5427 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5428 return resultobj;
5429fail:
5430 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5431 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5432 return NULL;
5433}
5434
5435
5436SWIGINTERN PyObject *_wrap_plbin(PyObject *self, PyObject *args) {
5437 PyObject *resultobj = 0;
5438 PLINT arg1 ;
5439 PLFLT *arg2 = (PLFLT *) 0 ;
5440 PLFLT *arg3 = (PLFLT *) 0 ;
5441 PLINT arg4 ;
5442 PyArrayObject *tmp1 = NULL ;
5443 PyArrayObject *tmp3 = NULL ;
5444 int val4 ;
5445 int ecode4 = 0 ;
5446 PyObject *swig_obj[3] ;
5447
5448 (void)self;
5449 if (!SWIG_Python_UnpackTuple(args, "plbin", 3, 3, swig_obj)) SWIG_fail;
5450 {
5451 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
5452 if ( tmp1 == NULL )
5453 return NULL;
5454 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
5455 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
5456 }
5457 {
5458 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
5459 if ( tmp3 == NULL )
5460 return NULL;
5461 if ( PyArray_DIMS( tmp3 )[0] != Alen )
5462 {
5463 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
5464 return NULL;
5465 }
5466 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
5467 }
5468 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
5469 if (!SWIG_IsOK(ecode4)) {
5470 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
5471 }
5472 arg4 = (PLINT)(val4);
5473 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
5474 resultobj = SWIG_Py_Void();
5475 {
5476 Py_CLEAR( tmp1 );
5477 }
5478 {
5479 Py_CLEAR( tmp3 );
5480 }
5481 return resultobj;
5482fail:
5483 {
5484 Py_CLEAR( tmp1 );
5485 }
5486 {
5487 Py_CLEAR( tmp3 );
5488 }
5489 return NULL;
5490}
5491
5492
5493SWIGINTERN PyObject *_wrap_plbtime(PyObject *self, PyObject *args) {
5494 PyObject *resultobj = 0;
5495 PLINT *arg1 = (PLINT *) 0 ;
5496 PLINT *arg2 = (PLINT *) 0 ;
5497 PLINT *arg3 = (PLINT *) 0 ;
5498 PLINT *arg4 = (PLINT *) 0 ;
5499 PLINT *arg5 = (PLINT *) 0 ;
5500 PLFLT *arg6 = (PLFLT *) 0 ;
5501 PLFLT arg7 ;
5502 PLINT temp1 ;
5503 int res1 = SWIG_TMPOBJ ;
5504 PLINT temp2 ;
5505 int res2 = SWIG_TMPOBJ ;
5506 PLINT temp3 ;
5507 int res3 = SWIG_TMPOBJ ;
5508 PLINT temp4 ;
5509 int res4 = SWIG_TMPOBJ ;
5510 PLINT temp5 ;
5511 int res5 = SWIG_TMPOBJ ;
5512 PLFLT temp6 ;
5513 int res6 = SWIG_TMPOBJ ;
5514 double val7 ;
5515 int ecode7 = 0 ;
5516 PyObject *swig_obj[1] ;
5517
5518 arg1 = &temp1;
5519 arg2 = &temp2;
5520 arg3 = &temp3;
5521 arg4 = &temp4;
5522 arg5 = &temp5;
5523 arg6 = &temp6;
5524 (void)self;
5525 if (!args) SWIG_fail;
5526 swig_obj[0] = args;
5527 ecode7 = SWIG_AsVal_double(swig_obj[0], &val7);
5528 if (!SWIG_IsOK(ecode7)) {
5529 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
5530 }
5531 arg7 = (PLFLT)(val7);
5532 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5533 resultobj = SWIG_Py_Void();
5534 if (SWIG_IsTmpObj(res1)) {
5535 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
5536 } else {
5537 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5538 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
5539 }
5540 if (SWIG_IsTmpObj(res2)) {
5541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
5542 } else {
5543 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
5545 }
5546 if (SWIG_IsTmpObj(res3)) {
5547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
5548 } else {
5549 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
5551 }
5552 if (SWIG_IsTmpObj(res4)) {
5553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
5554 } else {
5555 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
5557 }
5558 if (SWIG_IsTmpObj(res5)) {
5559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
5560 } else {
5561 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
5563 }
5564 if (SWIG_IsTmpObj(res6)) {
5565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 1);
5566 } else {
5567 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 1);
5569 }
5570 return resultobj;
5571fail:
5572 return NULL;
5573}
5574
5575
5576SWIGINTERN PyObject *_wrap_plbop(PyObject *self, PyObject *args) {
5577 PyObject *resultobj = 0;
5578
5579 (void)self;
5580 if (!SWIG_Python_UnpackTuple(args, "plbop", 0, 0, 0)) SWIG_fail;
5581 plbop();
5582 resultobj = SWIG_Py_Void();
5583 return resultobj;
5584fail:
5585 return NULL;
5586}
5587
5588
5589SWIGINTERN PyObject *_wrap_plbox(PyObject *self, PyObject *args) {
5590 PyObject *resultobj = 0;
5591 char *arg1 = (char *) 0 ;
5592 PLFLT arg2 ;
5593 PLINT arg3 ;
5594 char *arg4 = (char *) 0 ;
5595 PLFLT arg5 ;
5596 PLINT arg6 ;
5597 int res1 ;
5598 char *buf1 = 0 ;
5599 int alloc1 = 0 ;
5600 double val2 ;
5601 int ecode2 = 0 ;
5602 int val3 ;
5603 int ecode3 = 0 ;
5604 int res4 ;
5605 char *buf4 = 0 ;
5606 int alloc4 = 0 ;
5607 double val5 ;
5608 int ecode5 = 0 ;
5609 int val6 ;
5610 int ecode6 = 0 ;
5611 PyObject *swig_obj[6] ;
5612
5613 (void)self;
5614 if (!SWIG_Python_UnpackTuple(args, "plbox", 6, 6, swig_obj)) SWIG_fail;
5615 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
5618 }
5619 arg1 = (char *)(buf1);
5620 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5621 if (!SWIG_IsOK(ecode2)) {
5622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
5623 }
5624 arg2 = (PLFLT)(val2);
5625 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
5626 if (!SWIG_IsOK(ecode3)) {
5627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
5628 }
5629 arg3 = (PLINT)(val3);
5630 res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
5631 if (!SWIG_IsOK(res4)) {
5632 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
5633 }
5634 arg4 = (char *)(buf4);
5635 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
5636 if (!SWIG_IsOK(ecode5)) {
5637 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
5638 }
5639 arg5 = (PLFLT)(val5);
5640 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5641 if (!SWIG_IsOK(ecode6)) {
5642 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
5643 }
5644 arg6 = (PLINT)(val6);
5645 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
5646 resultobj = SWIG_Py_Void();
5647 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5648 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5649 return resultobj;
5650fail:
5651 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5652 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5653 return NULL;
5654}
5655
5656
5657SWIGINTERN PyObject *_wrap_plbox3(PyObject *self, PyObject *args) {
5658 PyObject *resultobj = 0;
5659 char *arg1 = (char *) 0 ;
5660 char *arg2 = (char *) 0 ;
5661 PLFLT arg3 ;
5662 PLINT arg4 ;
5663 char *arg5 = (char *) 0 ;
5664 char *arg6 = (char *) 0 ;
5665 PLFLT arg7 ;
5666 PLINT arg8 ;
5667 char *arg9 = (char *) 0 ;
5668 char *arg10 = (char *) 0 ;
5669 PLFLT arg11 ;
5670 PLINT arg12 ;
5671 int res1 ;
5672 char *buf1 = 0 ;
5673 int alloc1 = 0 ;
5674 int res2 ;
5675 char *buf2 = 0 ;
5676 int alloc2 = 0 ;
5677 double val3 ;
5678 int ecode3 = 0 ;
5679 int val4 ;
5680 int ecode4 = 0 ;
5681 int res5 ;
5682 char *buf5 = 0 ;
5683 int alloc5 = 0 ;
5684 int res6 ;
5685 char *buf6 = 0 ;
5686 int alloc6 = 0 ;
5687 double val7 ;
5688 int ecode7 = 0 ;
5689 int val8 ;
5690 int ecode8 = 0 ;
5691 int res9 ;
5692 char *buf9 = 0 ;
5693 int alloc9 = 0 ;
5694 int res10 ;
5695 char *buf10 = 0 ;
5696 int alloc10 = 0 ;
5697 double val11 ;
5698 int ecode11 = 0 ;
5699 int val12 ;
5700 int ecode12 = 0 ;
5701 PyObject *swig_obj[12] ;
5702
5703 (void)self;
5704 if (!SWIG_Python_UnpackTuple(args, "plbox3", 12, 12, swig_obj)) SWIG_fail;
5705 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
5706 if (!SWIG_IsOK(res1)) {
5707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
5708 }
5709 arg1 = (char *)(buf1);
5710 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
5711 if (!SWIG_IsOK(res2)) {
5712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
5713 }
5714 arg2 = (char *)(buf2);
5715 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5716 if (!SWIG_IsOK(ecode3)) {
5717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
5718 }
5719 arg3 = (PLFLT)(val3);
5720 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5721 if (!SWIG_IsOK(ecode4)) {
5722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
5723 }
5724 arg4 = (PLINT)(val4);
5725 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
5726 if (!SWIG_IsOK(res5)) {
5727 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
5728 }
5729 arg5 = (char *)(buf5);
5730 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
5731 if (!SWIG_IsOK(res6)) {
5732 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
5733 }
5734 arg6 = (char *)(buf6);
5735 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
5736 if (!SWIG_IsOK(ecode7)) {
5737 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
5738 }
5739 arg7 = (PLFLT)(val7);
5740 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5741 if (!SWIG_IsOK(ecode8)) {
5742 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
5743 }
5744 arg8 = (PLINT)(val8);
5745 res9 = SWIG_AsCharPtrAndSize(swig_obj[8], &buf9, NULL, &alloc9);
5746 if (!SWIG_IsOK(res9)) {
5747 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
5748 }
5749 arg9 = (char *)(buf9);
5750 res10 = SWIG_AsCharPtrAndSize(swig_obj[9], &buf10, NULL, &alloc10);
5751 if (!SWIG_IsOK(res10)) {
5752 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
5753 }
5754 arg10 = (char *)(buf10);
5755 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5756 if (!SWIG_IsOK(ecode11)) {
5757 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
5758 }
5759 arg11 = (PLFLT)(val11);
5760 ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
5761 if (!SWIG_IsOK(ecode12)) {
5762 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
5763 }
5764 arg12 = (PLINT)(val12);
5765 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);
5766 resultobj = SWIG_Py_Void();
5767 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5768 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5769 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5770 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5771 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5772 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5773 return resultobj;
5774fail:
5775 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5776 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5777 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5778 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
5779 if (alloc9 == SWIG_NEWOBJ) free((char*)buf9);
5780 if (alloc10 == SWIG_NEWOBJ) free((char*)buf10);
5781 return NULL;
5782}
5783
5784
5785SWIGINTERN PyObject *_wrap_plcalc_world(PyObject *self, PyObject *args) {
5786 PyObject *resultobj = 0;
5787 PLFLT arg1 ;
5788 PLFLT arg2 ;
5789 PLFLT *arg3 = (PLFLT *) 0 ;
5790 PLFLT *arg4 = (PLFLT *) 0 ;
5791 PLINT *arg5 = (PLINT *) 0 ;
5792 double val1 ;
5793 int ecode1 = 0 ;
5794 double val2 ;
5795 int ecode2 = 0 ;
5796 PLFLT temp3 ;
5797 int res3 = SWIG_TMPOBJ ;
5798 PLFLT temp4 ;
5799 int res4 = SWIG_TMPOBJ ;
5800 PLINT temp5 ;
5801 int res5 = SWIG_TMPOBJ ;
5802 PyObject *swig_obj[2] ;
5803
5804 arg3 = &temp3;
5805 arg4 = &temp4;
5806 arg5 = &temp5;
5807 (void)self;
5808 if (!SWIG_Python_UnpackTuple(args, "plcalc_world", 2, 2, swig_obj)) SWIG_fail;
5809 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5810 if (!SWIG_IsOK(ecode1)) {
5811 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
5812 }
5813 arg1 = (PLFLT)(val1);
5814 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5815 if (!SWIG_IsOK(ecode2)) {
5816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
5817 }
5818 arg2 = (PLFLT)(val2);
5819 plcalc_world(arg1,arg2,arg3,arg4,arg5);
5820 resultobj = SWIG_Py_Void();
5821 if (SWIG_IsTmpObj(res3)) {
5822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
5823 } else {
5824 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
5826 }
5827 if (SWIG_IsTmpObj(res4)) {
5828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
5829 } else {
5830 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5831 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
5832 }
5833 if (SWIG_IsTmpObj(res5)) {
5834 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
5835 } else {
5836 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5837 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
5838 }
5839 return resultobj;
5840fail:
5841 return NULL;
5842}
5843
5844
5845SWIGINTERN PyObject *_wrap_plclear(PyObject *self, PyObject *args) {
5846 PyObject *resultobj = 0;
5847
5848 (void)self;
5849 if (!SWIG_Python_UnpackTuple(args, "plclear", 0, 0, 0)) SWIG_fail;
5850 plclear();
5851 resultobj = SWIG_Py_Void();
5852 return resultobj;
5853fail:
5854 return NULL;
5855}
5856
5857
5858SWIGINTERN PyObject *_wrap_plcol0(PyObject *self, PyObject *args) {
5859 PyObject *resultobj = 0;
5860 PLINT arg1 ;
5861 int val1 ;
5862 int ecode1 = 0 ;
5863 PyObject *swig_obj[1] ;
5864
5865 (void)self;
5866 if (!args) SWIG_fail;
5867 swig_obj[0] = args;
5868 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
5869 if (!SWIG_IsOK(ecode1)) {
5870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
5871 }
5872 arg1 = (PLINT)(val1);
5873 plcol0(arg1);
5874 resultobj = SWIG_Py_Void();
5875 return resultobj;
5876fail:
5877 return NULL;
5878}
5879
5880
5881SWIGINTERN PyObject *_wrap_plcol1(PyObject *self, PyObject *args) {
5882 PyObject *resultobj = 0;
5883 PLFLT arg1 ;
5884 double val1 ;
5885 int ecode1 = 0 ;
5886 PyObject *swig_obj[1] ;
5887
5888 (void)self;
5889 if (!args) SWIG_fail;
5890 swig_obj[0] = args;
5891 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5892 if (!SWIG_IsOK(ecode1)) {
5893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
5894 }
5895 arg1 = (PLFLT)(val1);
5896 plcol1(arg1);
5897 resultobj = SWIG_Py_Void();
5898 return resultobj;
5899fail:
5900 return NULL;
5901}
5902
5903
5904SWIGINTERN PyObject *_wrap_plconfigtime(PyObject *self, PyObject *args) {
5905 PyObject *resultobj = 0;
5906 PLFLT arg1 ;
5907 PLFLT arg2 ;
5908 PLFLT arg3 ;
5909 PLINT arg4 ;
5910 PLBOOL arg5 ;
5911 PLINT arg6 ;
5912 PLINT arg7 ;
5913 PLINT arg8 ;
5914 PLINT arg9 ;
5915 PLINT arg10 ;
5916 PLFLT arg11 ;
5917 double val1 ;
5918 int ecode1 = 0 ;
5919 double val2 ;
5920 int ecode2 = 0 ;
5921 double val3 ;
5922 int ecode3 = 0 ;
5923 int val4 ;
5924 int ecode4 = 0 ;
5925 int val5 ;
5926 int ecode5 = 0 ;
5927 int val6 ;
5928 int ecode6 = 0 ;
5929 int val7 ;
5930 int ecode7 = 0 ;
5931 int val8 ;
5932 int ecode8 = 0 ;
5933 int val9 ;
5934 int ecode9 = 0 ;
5935 int val10 ;
5936 int ecode10 = 0 ;
5937 double val11 ;
5938 int ecode11 = 0 ;
5939 PyObject *swig_obj[11] ;
5940
5941 (void)self;
5942 if (!SWIG_Python_UnpackTuple(args, "plconfigtime", 11, 11, swig_obj)) SWIG_fail;
5943 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
5944 if (!SWIG_IsOK(ecode1)) {
5945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
5946 }
5947 arg1 = (PLFLT)(val1);
5948 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5949 if (!SWIG_IsOK(ecode2)) {
5950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
5951 }
5952 arg2 = (PLFLT)(val2);
5953 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
5954 if (!SWIG_IsOK(ecode3)) {
5955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
5956 }
5957 arg3 = (PLFLT)(val3);
5958 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
5959 if (!SWIG_IsOK(ecode4)) {
5960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
5961 }
5962 arg4 = (PLINT)(val4);
5963 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
5964 if (!SWIG_IsOK(ecode5)) {
5965 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
5966 }
5967 arg5 = (PLBOOL)(val5);
5968 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
5969 if (!SWIG_IsOK(ecode6)) {
5970 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
5971 }
5972 arg6 = (PLINT)(val6);
5973 ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
5974 if (!SWIG_IsOK(ecode7)) {
5975 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
5976 }
5977 arg7 = (PLINT)(val7);
5978 ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
5979 if (!SWIG_IsOK(ecode8)) {
5980 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
5981 }
5982 arg8 = (PLINT)(val8);
5983 ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
5984 if (!SWIG_IsOK(ecode9)) {
5985 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
5986 }
5987 arg9 = (PLINT)(val9);
5988 ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
5989 if (!SWIG_IsOK(ecode10)) {
5990 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
5991 }
5992 arg10 = (PLINT)(val10);
5993 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
5994 if (!SWIG_IsOK(ecode11)) {
5995 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
5996 }
5997 arg11 = (PLFLT)(val11);
5998 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
5999 resultobj = SWIG_Py_Void();
6000 return resultobj;
6001fail:
6002 return NULL;
6003}
6004
6005
6006SWIGINTERN PyObject *_wrap_plcont(PyObject *self, PyObject *args) {
6007 PyObject *resultobj = 0;
6008 PLFLT **arg1 = (PLFLT **) 0 ;
6009 PLINT arg2 ;
6010 PLINT arg3 ;
6011 PLINT arg4 ;
6012 PLINT arg5 ;
6013 PLINT arg6 ;
6014 PLINT arg7 ;
6015 PLFLT *arg8 = (PLFLT *) 0 ;
6016 PLINT arg9 ;
6017 pltr_func arg10 = (pltr_func) 0 ;
6018 PLPointer arg11 = (PLPointer) 0 ;
6019 PyArrayObject *tmp1 = NULL ;
6020 int val4 ;
6021 int ecode4 = 0 ;
6022 int val5 ;
6023 int ecode5 = 0 ;
6024 int val6 ;
6025 int ecode6 = 0 ;
6026 int val7 ;
6027 int ecode7 = 0 ;
6028 PyArrayObject *tmp8 = NULL ;
6029 PyObject *swig_obj[8] ;
6030
6031 {
6032 python_pltr = 0;
6033 arg10 = NULL;
6034 }
6035 {
6036 arg11 = NULL;
6037 }
6038 (void)self;
6039 if (!SWIG_Python_UnpackTuple(args, "plcont", 6, 8, swig_obj)) SWIG_fail;
6040 {
6041 int i, size;
6042 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
6043 if ( tmp1 == NULL )
6044 return NULL;
6045 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
6046 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
6047 size = arg3;
6048 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
6049 for ( i = 0; i < arg2; i++ )
6050 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
6051 }
6052 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
6053 if (!SWIG_IsOK(ecode4)) {
6054 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
6055 }
6056 arg4 = (PLINT)(val4);
6057 ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
6058 if (!SWIG_IsOK(ecode5)) {
6059 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
6060 }
6061 arg5 = (PLINT)(val5);
6062 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
6063 if (!SWIG_IsOK(ecode6)) {
6064 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
6065 }
6066 arg6 = (PLINT)(val6);
6067 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
6068 if (!SWIG_IsOK(ecode7)) {
6069 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
6070 }
6071 arg7 = (PLINT)(val7);
6072 {
6073 tmp8 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
6074 if ( tmp8 == NULL )
6075 return NULL;
6076 arg9 = PyArray_DIMS( tmp8 )[0];
6077 arg8 = (PLFLT *) PyArray_DATA( tmp8 );
6078 }
6079 if (swig_obj[6]) {
6080 {
6081 // it must be a callable or None
6082 if ( swig_obj[6] == Py_None )
6083 {
6084 arg10 = NULL;
6085 }
6086 else
6087 {
6088 if ( !PyCallable_Check( (PyObject *) swig_obj[6] ) )
6089 {
6090 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
6091 return NULL;
6092 }
6093 arg10 = marshal_pltr( swig_obj[6] );
6094 }
6095 }
6096 }
6097 if (swig_obj[7]) {
6098 {
6099 if ( swig_obj[7] == Py_None )
6100 arg11 = NULL;
6101 else
6102 {
6103 arg11 = marshal_PLPointer( swig_obj[7], 0 );
6104 }
6105 }
6106 }
6107 plcont((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11);
6108 resultobj = SWIG_Py_Void();
6109 {
6110 Py_CLEAR( tmp1 );
6111 free( arg1 );
6112 }
6113 {
6114 Py_CLEAR( tmp8 );
6115 }
6116 {
6117 cleanup_pltr();
6118 }
6119 {
6121 }
6122 return resultobj;
6123fail:
6124 {
6125 Py_CLEAR( tmp1 );
6126 free( arg1 );
6127 }
6128 {
6129 Py_CLEAR( tmp8 );
6130 }
6131 {
6132 cleanup_pltr();
6133 }
6134 {
6136 }
6137 return NULL;
6138}
6139
6140
6141SWIGINTERN PyObject *_wrap_plctime(PyObject *self, PyObject *args) {
6142 PyObject *resultobj = 0;
6143 PLINT arg1 ;
6144 PLINT arg2 ;
6145 PLINT arg3 ;
6146 PLINT arg4 ;
6147 PLINT arg5 ;
6148 PLFLT arg6 ;
6149 PLFLT *arg7 = (PLFLT *) 0 ;
6150 int val1 ;
6151 int ecode1 = 0 ;
6152 int val2 ;
6153 int ecode2 = 0 ;
6154 int val3 ;
6155 int ecode3 = 0 ;
6156 int val4 ;
6157 int ecode4 = 0 ;
6158 int val5 ;
6159 int ecode5 = 0 ;
6160 double val6 ;
6161 int ecode6 = 0 ;
6162 PLFLT temp7 ;
6163 int res7 = SWIG_TMPOBJ ;
6164 PyObject *swig_obj[6] ;
6165
6166 arg7 = &temp7;
6167 (void)self;
6168 if (!SWIG_Python_UnpackTuple(args, "plctime", 6, 6, swig_obj)) SWIG_fail;
6169 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6170 if (!SWIG_IsOK(ecode1)) {
6171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
6172 }
6173 arg1 = (PLINT)(val1);
6174 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6175 if (!SWIG_IsOK(ecode2)) {
6176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
6177 }
6178 arg2 = (PLINT)(val2);
6179 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
6180 if (!SWIG_IsOK(ecode3)) {
6181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
6182 }
6183 arg3 = (PLINT)(val3);
6184 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
6185 if (!SWIG_IsOK(ecode4)) {
6186 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
6187 }
6188 arg4 = (PLINT)(val4);
6189 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6190 if (!SWIG_IsOK(ecode5)) {
6191 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
6192 }
6193 arg5 = (PLINT)(val5);
6194 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
6195 if (!SWIG_IsOK(ecode6)) {
6196 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
6197 }
6198 arg6 = (PLFLT)(val6);
6199 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
6200 resultobj = SWIG_Py_Void();
6201 if (SWIG_IsTmpObj(res7)) {
6202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)), 1);
6203 } else {
6204 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags), 1);
6206 }
6207 return resultobj;
6208fail:
6209 return NULL;
6210}
6211
6212
6213SWIGINTERN PyObject *_wrap_plcpstrm(PyObject *self, PyObject *args) {
6214 PyObject *resultobj = 0;
6215 PLINT arg1 ;
6216 PLBOOL arg2 ;
6217 int val1 ;
6218 int ecode1 = 0 ;
6219 int val2 ;
6220 int ecode2 = 0 ;
6221 PyObject *swig_obj[2] ;
6222
6223 (void)self;
6224 if (!SWIG_Python_UnpackTuple(args, "plcpstrm", 2, 2, swig_obj)) SWIG_fail;
6225 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6226 if (!SWIG_IsOK(ecode1)) {
6227 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
6228 }
6229 arg1 = (PLINT)(val1);
6230 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
6231 if (!SWIG_IsOK(ecode2)) {
6232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
6233 }
6234 arg2 = (PLBOOL)(val2);
6235 plcpstrm(arg1,arg2);
6236 resultobj = SWIG_Py_Void();
6237 return resultobj;
6238fail:
6239 return NULL;
6240}
6241
6242
6243SWIGINTERN PyObject *_wrap_plend(PyObject *self, PyObject *args) {
6244 PyObject *resultobj = 0;
6245
6246 (void)self;
6247 if (!SWIG_Python_UnpackTuple(args, "plend", 0, 0, 0)) SWIG_fail;
6248 plend();
6249 resultobj = SWIG_Py_Void();
6250 return resultobj;
6251fail:
6252 return NULL;
6253}
6254
6255
6256SWIGINTERN PyObject *_wrap_plend1(PyObject *self, PyObject *args) {
6257 PyObject *resultobj = 0;
6258
6259 (void)self;
6260 if (!SWIG_Python_UnpackTuple(args, "plend1", 0, 0, 0)) SWIG_fail;
6261 plend1();
6262 resultobj = SWIG_Py_Void();
6263 return resultobj;
6264fail:
6265 return NULL;
6266}
6267
6268
6269SWIGINTERN PyObject *_wrap_plenv(PyObject *self, PyObject *args) {
6270 PyObject *resultobj = 0;
6271 PLFLT arg1 ;
6272 PLFLT arg2 ;
6273 PLFLT arg3 ;
6274 PLFLT arg4 ;
6275 PLINT arg5 ;
6276 PLINT arg6 ;
6277 double val1 ;
6278 int ecode1 = 0 ;
6279 double val2 ;
6280 int ecode2 = 0 ;
6281 double val3 ;
6282 int ecode3 = 0 ;
6283 double val4 ;
6284 int ecode4 = 0 ;
6285 int val5 ;
6286 int ecode5 = 0 ;
6287 int val6 ;
6288 int ecode6 = 0 ;
6289 PyObject *swig_obj[6] ;
6290
6291 (void)self;
6292 if (!SWIG_Python_UnpackTuple(args, "plenv", 6, 6, swig_obj)) SWIG_fail;
6293 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6294 if (!SWIG_IsOK(ecode1)) {
6295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
6296 }
6297 arg1 = (PLFLT)(val1);
6298 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6299 if (!SWIG_IsOK(ecode2)) {
6300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
6301 }
6302 arg2 = (PLFLT)(val2);
6303 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6304 if (!SWIG_IsOK(ecode3)) {
6305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
6306 }
6307 arg3 = (PLFLT)(val3);
6308 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6309 if (!SWIG_IsOK(ecode4)) {
6310 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
6311 }
6312 arg4 = (PLFLT)(val4);
6313 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6314 if (!SWIG_IsOK(ecode5)) {
6315 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
6316 }
6317 arg5 = (PLINT)(val5);
6318 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6319 if (!SWIG_IsOK(ecode6)) {
6320 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
6321 }
6322 arg6 = (PLINT)(val6);
6323 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
6324 resultobj = SWIG_Py_Void();
6325 return resultobj;
6326fail:
6327 return NULL;
6328}
6329
6330
6331SWIGINTERN PyObject *_wrap_plenv0(PyObject *self, PyObject *args) {
6332 PyObject *resultobj = 0;
6333 PLFLT arg1 ;
6334 PLFLT arg2 ;
6335 PLFLT arg3 ;
6336 PLFLT arg4 ;
6337 PLINT arg5 ;
6338 PLINT arg6 ;
6339 double val1 ;
6340 int ecode1 = 0 ;
6341 double val2 ;
6342 int ecode2 = 0 ;
6343 double val3 ;
6344 int ecode3 = 0 ;
6345 double val4 ;
6346 int ecode4 = 0 ;
6347 int val5 ;
6348 int ecode5 = 0 ;
6349 int val6 ;
6350 int ecode6 = 0 ;
6351 PyObject *swig_obj[6] ;
6352
6353 (void)self;
6354 if (!SWIG_Python_UnpackTuple(args, "plenv0", 6, 6, swig_obj)) SWIG_fail;
6355 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
6356 if (!SWIG_IsOK(ecode1)) {
6357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
6358 }
6359 arg1 = (PLFLT)(val1);
6360 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
6361 if (!SWIG_IsOK(ecode2)) {
6362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
6363 }
6364 arg2 = (PLFLT)(val2);
6365 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
6366 if (!SWIG_IsOK(ecode3)) {
6367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
6368 }
6369 arg3 = (PLFLT)(val3);
6370 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
6371 if (!SWIG_IsOK(ecode4)) {
6372 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
6373 }
6374 arg4 = (PLFLT)(val4);
6375 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
6376 if (!SWIG_IsOK(ecode5)) {
6377 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
6378 }
6379 arg5 = (PLINT)(val5);
6380 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
6381 if (!SWIG_IsOK(ecode6)) {
6382 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
6383 }
6384 arg6 = (PLINT)(val6);
6385 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
6386 resultobj = SWIG_Py_Void();
6387 return resultobj;
6388fail:
6389 return NULL;
6390}
6391
6392
6393SWIGINTERN PyObject *_wrap_pleop(PyObject *self, PyObject *args) {
6394 PyObject *resultobj = 0;
6395
6396 (void)self;
6397 if (!SWIG_Python_UnpackTuple(args, "pleop", 0, 0, 0)) SWIG_fail;
6398 pleop();
6399 resultobj = SWIG_Py_Void();
6400 return resultobj;
6401fail:
6402 return NULL;
6403}
6404
6405
6406SWIGINTERN PyObject *_wrap_plerrx(PyObject *self, PyObject *args) {
6407 PyObject *resultobj = 0;
6408 PLINT arg1 ;
6409 PLFLT *arg2 = (PLFLT *) 0 ;
6410 PLFLT *arg3 = (PLFLT *) 0 ;
6411 PLFLT *arg4 = (PLFLT *) 0 ;
6412 PyArrayObject *tmp1 = NULL ;
6413 PyArrayObject *tmp3 = NULL ;
6414 PyArrayObject *tmp4 = NULL ;
6415 PyObject *swig_obj[3] ;
6416
6417 (void)self;
6418 if (!SWIG_Python_UnpackTuple(args, "plerrx", 3, 3, swig_obj)) SWIG_fail;
6419 {
6420 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6421 if ( tmp1 == NULL )
6422 return NULL;
6423 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6424 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6425 }
6426 {
6427 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6428 if ( tmp3 == NULL )
6429 return NULL;
6430 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6431 {
6432 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6433 return NULL;
6434 }
6435 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6436 }
6437 {
6438 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6439 if ( tmp4 == NULL )
6440 return NULL;
6441 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6442 {
6443 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6444 return NULL;
6445 }
6446 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6447 }
6448 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6449 resultobj = SWIG_Py_Void();
6450 {
6451 Py_CLEAR( tmp1 );
6452 }
6453 {
6454 Py_CLEAR( tmp3 );
6455 }
6456 {
6457 Py_CLEAR( tmp4 );
6458 }
6459 return resultobj;
6460fail:
6461 {
6462 Py_CLEAR( tmp1 );
6463 }
6464 {
6465 Py_CLEAR( tmp3 );
6466 }
6467 {
6468 Py_CLEAR( tmp4 );
6469 }
6470 return NULL;
6471}
6472
6473
6474SWIGINTERN PyObject *_wrap_plerry(PyObject *self, PyObject *args) {
6475 PyObject *resultobj = 0;
6476 PLINT arg1 ;
6477 PLFLT *arg2 = (PLFLT *) 0 ;
6478 PLFLT *arg3 = (PLFLT *) 0 ;
6479 PLFLT *arg4 = (PLFLT *) 0 ;
6480 PyArrayObject *tmp1 = NULL ;
6481 PyArrayObject *tmp3 = NULL ;
6482 PyArrayObject *tmp4 = NULL ;
6483 PyObject *swig_obj[3] ;
6484
6485 (void)self;
6486 if (!SWIG_Python_UnpackTuple(args, "plerry", 3, 3, swig_obj)) SWIG_fail;
6487 {
6488 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6489 if ( tmp1 == NULL )
6490 return NULL;
6491 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6492 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6493 }
6494 {
6495 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6496 if ( tmp3 == NULL )
6497 return NULL;
6498 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6499 {
6500 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6501 return NULL;
6502 }
6503 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6504 }
6505 {
6506 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6507 if ( tmp4 == NULL )
6508 return NULL;
6509 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6510 {
6511 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6512 return NULL;
6513 }
6514 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6515 }
6516 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6517 resultobj = SWIG_Py_Void();
6518 {
6519 Py_CLEAR( tmp1 );
6520 }
6521 {
6522 Py_CLEAR( tmp3 );
6523 }
6524 {
6525 Py_CLEAR( tmp4 );
6526 }
6527 return resultobj;
6528fail:
6529 {
6530 Py_CLEAR( tmp1 );
6531 }
6532 {
6533 Py_CLEAR( tmp3 );
6534 }
6535 {
6536 Py_CLEAR( tmp4 );
6537 }
6538 return NULL;
6539}
6540
6541
6542SWIGINTERN PyObject *_wrap_plfamadv(PyObject *self, PyObject *args) {
6543 PyObject *resultobj = 0;
6544
6545 (void)self;
6546 if (!SWIG_Python_UnpackTuple(args, "plfamadv", 0, 0, 0)) SWIG_fail;
6547 plfamadv();
6548 resultobj = SWIG_Py_Void();
6549 return resultobj;
6550fail:
6551 return NULL;
6552}
6553
6554
6555SWIGINTERN PyObject *_wrap_plfill(PyObject *self, PyObject *args) {
6556 PyObject *resultobj = 0;
6557 PLINT arg1 ;
6558 PLFLT *arg2 = (PLFLT *) 0 ;
6559 PLFLT *arg3 = (PLFLT *) 0 ;
6560 PyArrayObject *tmp1 = NULL ;
6561 PyArrayObject *tmp3 = NULL ;
6562 PyObject *swig_obj[2] ;
6563
6564 (void)self;
6565 if (!SWIG_Python_UnpackTuple(args, "plfill", 2, 2, swig_obj)) SWIG_fail;
6566 {
6567 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6568 if ( tmp1 == NULL )
6569 return NULL;
6570 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6571 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6572 }
6573 {
6574 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6575 if ( tmp3 == NULL )
6576 return NULL;
6577 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6578 {
6579 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6580 return NULL;
6581 }
6582 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6583 }
6584 plfill(arg1,(double const *)arg2,(double const *)arg3);
6585 resultobj = SWIG_Py_Void();
6586 {
6587 Py_CLEAR( tmp1 );
6588 }
6589 {
6590 Py_CLEAR( tmp3 );
6591 }
6592 return resultobj;
6593fail:
6594 {
6595 Py_CLEAR( tmp1 );
6596 }
6597 {
6598 Py_CLEAR( tmp3 );
6599 }
6600 return NULL;
6601}
6602
6603
6604SWIGINTERN PyObject *_wrap_plfill3(PyObject *self, PyObject *args) {
6605 PyObject *resultobj = 0;
6606 PLINT arg1 ;
6607 PLFLT *arg2 = (PLFLT *) 0 ;
6608 PLFLT *arg3 = (PLFLT *) 0 ;
6609 PLFLT *arg4 = (PLFLT *) 0 ;
6610 PyArrayObject *tmp1 = NULL ;
6611 PyArrayObject *tmp3 = NULL ;
6612 PyArrayObject *tmp4 = NULL ;
6613 PyObject *swig_obj[3] ;
6614
6615 (void)self;
6616 if (!SWIG_Python_UnpackTuple(args, "plfill3", 3, 3, swig_obj)) SWIG_fail;
6617 {
6618 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6619 if ( tmp1 == NULL )
6620 return NULL;
6621 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6622 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6623 }
6624 {
6625 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6626 if ( tmp3 == NULL )
6627 return NULL;
6628 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6629 {
6630 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6631 return NULL;
6632 }
6633 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6634 }
6635 {
6636 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
6637 if ( tmp4 == NULL )
6638 return NULL;
6639 if ( PyArray_DIMS( tmp4 )[0] != Alen )
6640 {
6641 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6642 return NULL;
6643 }
6644 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
6645 }
6646 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
6647 resultobj = SWIG_Py_Void();
6648 {
6649 Py_CLEAR( tmp1 );
6650 }
6651 {
6652 Py_CLEAR( tmp3 );
6653 }
6654 {
6655 Py_CLEAR( tmp4 );
6656 }
6657 return resultobj;
6658fail:
6659 {
6660 Py_CLEAR( tmp1 );
6661 }
6662 {
6663 Py_CLEAR( tmp3 );
6664 }
6665 {
6666 Py_CLEAR( tmp4 );
6667 }
6668 return NULL;
6669}
6670
6671
6672SWIGINTERN PyObject *_wrap_plgradient(PyObject *self, PyObject *args) {
6673 PyObject *resultobj = 0;
6674 PLINT arg1 ;
6675 PLFLT *arg2 = (PLFLT *) 0 ;
6676 PLFLT *arg3 = (PLFLT *) 0 ;
6677 PLFLT arg4 ;
6678 PyArrayObject *tmp1 = NULL ;
6679 PyArrayObject *tmp3 = NULL ;
6680 double val4 ;
6681 int ecode4 = 0 ;
6682 PyObject *swig_obj[3] ;
6683
6684 (void)self;
6685 if (!SWIG_Python_UnpackTuple(args, "plgradient", 3, 3, swig_obj)) SWIG_fail;
6686 {
6687 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
6688 if ( tmp1 == NULL )
6689 return NULL;
6690 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
6691 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
6692 }
6693 {
6694 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
6695 if ( tmp3 == NULL )
6696 return NULL;
6697 if ( PyArray_DIMS( tmp3 )[0] != Alen )
6698 {
6699 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
6700 return NULL;
6701 }
6702 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
6703 }
6704 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
6705 if (!SWIG_IsOK(ecode4)) {
6706 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
6707 }
6708 arg4 = (PLFLT)(val4);
6709 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
6710 resultobj = SWIG_Py_Void();
6711 {
6712 Py_CLEAR( tmp1 );
6713 }
6714 {
6715 Py_CLEAR( tmp3 );
6716 }
6717 return resultobj;
6718fail:
6719 {
6720 Py_CLEAR( tmp1 );
6721 }
6722 {
6723 Py_CLEAR( tmp3 );
6724 }
6725 return NULL;
6726}
6727
6728
6729SWIGINTERN PyObject *_wrap_plflush(PyObject *self, PyObject *args) {
6730 PyObject *resultobj = 0;
6731
6732 (void)self;
6733 if (!SWIG_Python_UnpackTuple(args, "plflush", 0, 0, 0)) SWIG_fail;
6734 plflush();
6735 resultobj = SWIG_Py_Void();
6736 return resultobj;
6737fail:
6738 return NULL;
6739}
6740
6741
6742SWIGINTERN PyObject *_wrap_plfont(PyObject *self, PyObject *args) {
6743 PyObject *resultobj = 0;
6744 PLINT arg1 ;
6745 int val1 ;
6746 int ecode1 = 0 ;
6747 PyObject *swig_obj[1] ;
6748
6749 (void)self;
6750 if (!args) SWIG_fail;
6751 swig_obj[0] = args;
6752 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6753 if (!SWIG_IsOK(ecode1)) {
6754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
6755 }
6756 arg1 = (PLINT)(val1);
6757 plfont(arg1);
6758 resultobj = SWIG_Py_Void();
6759 return resultobj;
6760fail:
6761 return NULL;
6762}
6763
6764
6765SWIGINTERN PyObject *_wrap_plfontld(PyObject *self, PyObject *args) {
6766 PyObject *resultobj = 0;
6767 PLINT arg1 ;
6768 int val1 ;
6769 int ecode1 = 0 ;
6770 PyObject *swig_obj[1] ;
6771
6772 (void)self;
6773 if (!args) SWIG_fail;
6774 swig_obj[0] = args;
6775 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6776 if (!SWIG_IsOK(ecode1)) {
6777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
6778 }
6779 arg1 = (PLINT)(val1);
6780 plfontld(arg1);
6781 resultobj = SWIG_Py_Void();
6782 return resultobj;
6783fail:
6784 return NULL;
6785}
6786
6787
6788SWIGINTERN PyObject *_wrap_plgchr(PyObject *self, PyObject *args) {
6789 PyObject *resultobj = 0;
6790 PLFLT *arg1 = (PLFLT *) 0 ;
6791 PLFLT *arg2 = (PLFLT *) 0 ;
6792 PLFLT temp1 ;
6793 int res1 = SWIG_TMPOBJ ;
6794 PLFLT temp2 ;
6795 int res2 = SWIG_TMPOBJ ;
6796
6797 arg1 = &temp1;
6798 arg2 = &temp2;
6799 (void)self;
6800 if (!SWIG_Python_UnpackTuple(args, "plgchr", 0, 0, 0)) SWIG_fail;
6801 plgchr(arg1,arg2);
6802 resultobj = SWIG_Py_Void();
6803 if (SWIG_IsTmpObj(res1)) {
6804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
6805 } else {
6806 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
6808 }
6809 if (SWIG_IsTmpObj(res2)) {
6810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
6811 } else {
6812 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
6814 }
6815 return resultobj;
6816fail:
6817 return NULL;
6818}
6819
6820
6821SWIGINTERN PyObject *_wrap_plgcol0(PyObject *self, PyObject *args) {
6822 PyObject *resultobj = 0;
6823 PLINT arg1 ;
6824 PLINT *arg2 = (PLINT *) 0 ;
6825 PLINT *arg3 = (PLINT *) 0 ;
6826 PLINT *arg4 = (PLINT *) 0 ;
6827 int val1 ;
6828 int ecode1 = 0 ;
6829 PLINT temp2 ;
6830 int res2 = SWIG_TMPOBJ ;
6831 PLINT temp3 ;
6832 int res3 = SWIG_TMPOBJ ;
6833 PLINT temp4 ;
6834 int res4 = SWIG_TMPOBJ ;
6835 PyObject *swig_obj[1] ;
6836
6837 arg2 = &temp2;
6838 arg3 = &temp3;
6839 arg4 = &temp4;
6840 (void)self;
6841 if (!args) SWIG_fail;
6842 swig_obj[0] = args;
6843 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6844 if (!SWIG_IsOK(ecode1)) {
6845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
6846 }
6847 arg1 = (PLINT)(val1);
6848 plgcol0(arg1,arg2,arg3,arg4);
6849 resultobj = SWIG_Py_Void();
6850 if (SWIG_IsTmpObj(res2)) {
6851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
6852 } else {
6853 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6854 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
6855 }
6856 if (SWIG_IsTmpObj(res3)) {
6857 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
6858 } else {
6859 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6860 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
6861 }
6862 if (SWIG_IsTmpObj(res4)) {
6863 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
6864 } else {
6865 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6866 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
6867 }
6868 return resultobj;
6869fail:
6870 return NULL;
6871}
6872
6873
6874SWIGINTERN PyObject *_wrap_plgcol0a(PyObject *self, PyObject *args) {
6875 PyObject *resultobj = 0;
6876 PLINT arg1 ;
6877 PLINT *arg2 = (PLINT *) 0 ;
6878 PLINT *arg3 = (PLINT *) 0 ;
6879 PLINT *arg4 = (PLINT *) 0 ;
6880 PLFLT *arg5 = (PLFLT *) 0 ;
6881 int val1 ;
6882 int ecode1 = 0 ;
6883 PLINT temp2 ;
6884 int res2 = SWIG_TMPOBJ ;
6885 PLINT temp3 ;
6886 int res3 = SWIG_TMPOBJ ;
6887 PLINT temp4 ;
6888 int res4 = SWIG_TMPOBJ ;
6889 PLFLT temp5 ;
6890 int res5 = SWIG_TMPOBJ ;
6891 PyObject *swig_obj[1] ;
6892
6893 arg2 = &temp2;
6894 arg3 = &temp3;
6895 arg4 = &temp4;
6896 arg5 = &temp5;
6897 (void)self;
6898 if (!args) SWIG_fail;
6899 swig_obj[0] = args;
6900 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
6901 if (!SWIG_IsOK(ecode1)) {
6902 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
6903 }
6904 arg1 = (PLINT)(val1);
6905 plgcol0a(arg1,arg2,arg3,arg4,arg5);
6906 resultobj = SWIG_Py_Void();
6907 if (SWIG_IsTmpObj(res2)) {
6908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
6909 } else {
6910 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
6912 }
6913 if (SWIG_IsTmpObj(res3)) {
6914 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
6915 } else {
6916 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
6918 }
6919 if (SWIG_IsTmpObj(res4)) {
6920 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
6921 } else {
6922 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
6924 }
6925 if (SWIG_IsTmpObj(res5)) {
6926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
6927 } else {
6928 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
6930 }
6931 return resultobj;
6932fail:
6933 return NULL;
6934}
6935
6936
6937SWIGINTERN PyObject *_wrap_plgcolbg(PyObject *self, PyObject *args) {
6938 PyObject *resultobj = 0;
6939 PLINT *arg1 = (PLINT *) 0 ;
6940 PLINT *arg2 = (PLINT *) 0 ;
6941 PLINT *arg3 = (PLINT *) 0 ;
6942 PLINT temp1 ;
6943 int res1 = SWIG_TMPOBJ ;
6944 PLINT temp2 ;
6945 int res2 = SWIG_TMPOBJ ;
6946 PLINT temp3 ;
6947 int res3 = SWIG_TMPOBJ ;
6948
6949 arg1 = &temp1;
6950 arg2 = &temp2;
6951 arg3 = &temp3;
6952 (void)self;
6953 if (!SWIG_Python_UnpackTuple(args, "plgcolbg", 0, 0, 0)) SWIG_fail;
6954 plgcolbg(arg1,arg2,arg3);
6955 resultobj = SWIG_Py_Void();
6956 if (SWIG_IsTmpObj(res1)) {
6957 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
6958 } else {
6959 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
6961 }
6962 if (SWIG_IsTmpObj(res2)) {
6963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
6964 } else {
6965 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
6967 }
6968 if (SWIG_IsTmpObj(res3)) {
6969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
6970 } else {
6971 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
6973 }
6974 return resultobj;
6975fail:
6976 return NULL;
6977}
6978
6979
6980SWIGINTERN PyObject *_wrap_plgcolbga(PyObject *self, PyObject *args) {
6981 PyObject *resultobj = 0;
6982 PLINT *arg1 = (PLINT *) 0 ;
6983 PLINT *arg2 = (PLINT *) 0 ;
6984 PLINT *arg3 = (PLINT *) 0 ;
6985 PLFLT *arg4 = (PLFLT *) 0 ;
6986 PLINT temp1 ;
6987 int res1 = SWIG_TMPOBJ ;
6988 PLINT temp2 ;
6989 int res2 = SWIG_TMPOBJ ;
6990 PLINT temp3 ;
6991 int res3 = SWIG_TMPOBJ ;
6992 PLFLT temp4 ;
6993 int res4 = SWIG_TMPOBJ ;
6994
6995 arg1 = &temp1;
6996 arg2 = &temp2;
6997 arg3 = &temp3;
6998 arg4 = &temp4;
6999 (void)self;
7000 if (!SWIG_Python_UnpackTuple(args, "plgcolbga", 0, 0, 0)) SWIG_fail;
7001 plgcolbga(arg1,arg2,arg3,arg4);
7002 resultobj = SWIG_Py_Void();
7003 if (SWIG_IsTmpObj(res1)) {
7004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7005 } else {
7006 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7008 }
7009 if (SWIG_IsTmpObj(res2)) {
7010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7011 } else {
7012 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7014 }
7015 if (SWIG_IsTmpObj(res3)) {
7016 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7017 } else {
7018 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7019 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7020 }
7021 if (SWIG_IsTmpObj(res4)) {
7022 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7023 } else {
7024 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7025 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7026 }
7027 return resultobj;
7028fail:
7029 return NULL;
7030}
7031
7032
7033SWIGINTERN PyObject *_wrap_plgcompression(PyObject *self, PyObject *args) {
7034 PyObject *resultobj = 0;
7035 PLINT *arg1 = (PLINT *) 0 ;
7036 PLINT temp1 ;
7037 int res1 = SWIG_TMPOBJ ;
7038
7039 arg1 = &temp1;
7040 (void)self;
7041 if (!SWIG_Python_UnpackTuple(args, "plgcompression", 0, 0, 0)) SWIG_fail;
7042 plgcompression(arg1);
7043 resultobj = SWIG_Py_Void();
7044 if (SWIG_IsTmpObj(res1)) {
7045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7046 } else {
7047 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7049 }
7050 return resultobj;
7051fail:
7052 return NULL;
7053}
7054
7055
7056SWIGINTERN PyObject *_wrap_plgdev(PyObject *self, PyObject *args) {
7057 PyObject *resultobj = 0;
7058 char *arg1 = (char *) 0 ;
7059 char buff1[1000] ;
7060
7061 {
7062 arg1 = buff1;
7063 }
7064 (void)self;
7065 if (!SWIG_Python_UnpackTuple(args, "plgdev", 0, 0, 0)) SWIG_fail;
7066 plgdev(arg1);
7067 resultobj = SWIG_Py_Void();
7068 {
7069 PyObject *o = PyString_FromString( arg1 );
7070 resultobj = SWIG_Python_AppendOutput(resultobj, o, 1);
7071 }
7072 return resultobj;
7073fail:
7074 return NULL;
7075}
7076
7077
7078SWIGINTERN PyObject *_wrap_plgdidev(PyObject *self, PyObject *args) {
7079 PyObject *resultobj = 0;
7080 PLFLT *arg1 = (PLFLT *) 0 ;
7081 PLFLT *arg2 = (PLFLT *) 0 ;
7082 PLFLT *arg3 = (PLFLT *) 0 ;
7083 PLFLT *arg4 = (PLFLT *) 0 ;
7084 PLFLT temp1 ;
7085 int res1 = SWIG_TMPOBJ ;
7086 PLFLT temp2 ;
7087 int res2 = SWIG_TMPOBJ ;
7088 PLFLT temp3 ;
7089 int res3 = SWIG_TMPOBJ ;
7090 PLFLT temp4 ;
7091 int res4 = SWIG_TMPOBJ ;
7092
7093 arg1 = &temp1;
7094 arg2 = &temp2;
7095 arg3 = &temp3;
7096 arg4 = &temp4;
7097 (void)self;
7098 if (!SWIG_Python_UnpackTuple(args, "plgdidev", 0, 0, 0)) SWIG_fail;
7099 plgdidev(arg1,arg2,arg3,arg4);
7100 resultobj = SWIG_Py_Void();
7101 if (SWIG_IsTmpObj(res1)) {
7102 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7103 } else {
7104 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7105 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7106 }
7107 if (SWIG_IsTmpObj(res2)) {
7108 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7109 } else {
7110 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7111 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7112 }
7113 if (SWIG_IsTmpObj(res3)) {
7114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7115 } else {
7116 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7118 }
7119 if (SWIG_IsTmpObj(res4)) {
7120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7121 } else {
7122 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7124 }
7125 return resultobj;
7126fail:
7127 return NULL;
7128}
7129
7130
7131SWIGINTERN PyObject *_wrap_plgdiori(PyObject *self, PyObject *args) {
7132 PyObject *resultobj = 0;
7133 PLFLT *arg1 = (PLFLT *) 0 ;
7134 PLFLT temp1 ;
7135 int res1 = SWIG_TMPOBJ ;
7136
7137 arg1 = &temp1;
7138 (void)self;
7139 if (!SWIG_Python_UnpackTuple(args, "plgdiori", 0, 0, 0)) SWIG_fail;
7140 plgdiori(arg1);
7141 resultobj = SWIG_Py_Void();
7142 if (SWIG_IsTmpObj(res1)) {
7143 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7144 } else {
7145 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7147 }
7148 return resultobj;
7149fail:
7150 return NULL;
7151}
7152
7153
7154SWIGINTERN PyObject *_wrap_plgdiplt(PyObject *self, PyObject *args) {
7155 PyObject *resultobj = 0;
7156 PLFLT *arg1 = (PLFLT *) 0 ;
7157 PLFLT *arg2 = (PLFLT *) 0 ;
7158 PLFLT *arg3 = (PLFLT *) 0 ;
7159 PLFLT *arg4 = (PLFLT *) 0 ;
7160 PLFLT temp1 ;
7161 int res1 = SWIG_TMPOBJ ;
7162 PLFLT temp2 ;
7163 int res2 = SWIG_TMPOBJ ;
7164 PLFLT temp3 ;
7165 int res3 = SWIG_TMPOBJ ;
7166 PLFLT temp4 ;
7167 int res4 = SWIG_TMPOBJ ;
7168
7169 arg1 = &temp1;
7170 arg2 = &temp2;
7171 arg3 = &temp3;
7172 arg4 = &temp4;
7173 (void)self;
7174 if (!SWIG_Python_UnpackTuple(args, "plgdiplt", 0, 0, 0)) SWIG_fail;
7175 plgdiplt(arg1,arg2,arg3,arg4);
7176 resultobj = SWIG_Py_Void();
7177 if (SWIG_IsTmpObj(res1)) {
7178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7179 } else {
7180 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7182 }
7183 if (SWIG_IsTmpObj(res2)) {
7184 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7185 } else {
7186 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7188 }
7189 if (SWIG_IsTmpObj(res3)) {
7190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7191 } else {
7192 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7194 }
7195 if (SWIG_IsTmpObj(res4)) {
7196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7197 } else {
7198 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7200 }
7201 return resultobj;
7202fail:
7203 return NULL;
7204}
7205
7206
7207SWIGINTERN PyObject *_wrap_plgfam(PyObject *self, PyObject *args) {
7208 PyObject *resultobj = 0;
7209 PLINT *arg1 = (PLINT *) 0 ;
7210 PLINT *arg2 = (PLINT *) 0 ;
7211 PLINT *arg3 = (PLINT *) 0 ;
7212 PLINT temp1 ;
7213 int res1 = SWIG_TMPOBJ ;
7214 PLINT temp2 ;
7215 int res2 = SWIG_TMPOBJ ;
7216 PLINT temp3 ;
7217 int res3 = SWIG_TMPOBJ ;
7218
7219 arg1 = &temp1;
7220 arg2 = &temp2;
7221 arg3 = &temp3;
7222 (void)self;
7223 if (!SWIG_Python_UnpackTuple(args, "plgfam", 0, 0, 0)) SWIG_fail;
7224 plgfam(arg1,arg2,arg3);
7225 resultobj = SWIG_Py_Void();
7226 if (SWIG_IsTmpObj(res1)) {
7227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7228 } else {
7229 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7231 }
7232 if (SWIG_IsTmpObj(res2)) {
7233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7234 } else {
7235 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7237 }
7238 if (SWIG_IsTmpObj(res3)) {
7239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7240 } else {
7241 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7243 }
7244 return resultobj;
7245fail:
7246 return NULL;
7247}
7248
7249
7250SWIGINTERN PyObject *_wrap_plgfci(PyObject *self, PyObject *args) {
7251 PyObject *resultobj = 0;
7252 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
7253 PLUNICODE temp1 ;
7254 int res1 = SWIG_TMPOBJ ;
7255
7256 arg1 = &temp1;
7257 (void)self;
7258 if (!SWIG_Python_UnpackTuple(args, "plgfci", 0, 0, 0)) SWIG_fail;
7259 plgfci(arg1);
7260 resultobj = SWIG_Py_Void();
7261 if (SWIG_IsTmpObj(res1)) {
7262 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg1)), 1);
7263 } else {
7264 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags), 1);
7266 }
7267 return resultobj;
7268fail:
7269 return NULL;
7270}
7271
7272
7273SWIGINTERN PyObject *_wrap_plgfnam(PyObject *self, PyObject *args) {
7274 PyObject *resultobj = 0;
7275 char *arg1 = (char *) 0 ;
7276 char buff1[1000] ;
7277
7278 {
7279 arg1 = buff1;
7280 }
7281 (void)self;
7282 if (!SWIG_Python_UnpackTuple(args, "plgfnam", 0, 0, 0)) SWIG_fail;
7283 plgfnam(arg1);
7284 resultobj = SWIG_Py_Void();
7285 {
7286 PyObject *o = PyString_FromString( arg1 );
7287 resultobj = SWIG_Python_AppendOutput(resultobj, o, 1);
7288 }
7289 return resultobj;
7290fail:
7291 return NULL;
7292}
7293
7294
7295SWIGINTERN PyObject *_wrap_plgfont(PyObject *self, PyObject *args) {
7296 PyObject *resultobj = 0;
7297 PLINT *arg1 = (PLINT *) 0 ;
7298 PLINT *arg2 = (PLINT *) 0 ;
7299 PLINT *arg3 = (PLINT *) 0 ;
7300 PLINT temp1 ;
7301 int res1 = SWIG_TMPOBJ ;
7302 PLINT temp2 ;
7303 int res2 = SWIG_TMPOBJ ;
7304 PLINT temp3 ;
7305 int res3 = SWIG_TMPOBJ ;
7306
7307 arg1 = &temp1;
7308 arg2 = &temp2;
7309 arg3 = &temp3;
7310 (void)self;
7311 if (!SWIG_Python_UnpackTuple(args, "plgfont", 0, 0, 0)) SWIG_fail;
7312 plgfont(arg1,arg2,arg3);
7313 resultobj = SWIG_Py_Void();
7314 if (SWIG_IsTmpObj(res1)) {
7315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7316 } else {
7317 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7319 }
7320 if (SWIG_IsTmpObj(res2)) {
7321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7322 } else {
7323 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7325 }
7326 if (SWIG_IsTmpObj(res3)) {
7327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7328 } else {
7329 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7331 }
7332 return resultobj;
7333fail:
7334 return NULL;
7335}
7336
7337
7338SWIGINTERN PyObject *_wrap_plglevel(PyObject *self, PyObject *args) {
7339 PyObject *resultobj = 0;
7340 PLINT *arg1 = (PLINT *) 0 ;
7341 PLINT temp1 ;
7342 int res1 = SWIG_TMPOBJ ;
7343
7344 arg1 = &temp1;
7345 (void)self;
7346 if (!SWIG_Python_UnpackTuple(args, "plglevel", 0, 0, 0)) SWIG_fail;
7347 plglevel(arg1);
7348 resultobj = SWIG_Py_Void();
7349 if (SWIG_IsTmpObj(res1)) {
7350 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7351 } else {
7352 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7353 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7354 }
7355 return resultobj;
7356fail:
7357 return NULL;
7358}
7359
7360
7361SWIGINTERN PyObject *_wrap_plgpage(PyObject *self, PyObject *args) {
7362 PyObject *resultobj = 0;
7363 PLFLT *arg1 = (PLFLT *) 0 ;
7364 PLFLT *arg2 = (PLFLT *) 0 ;
7365 PLINT *arg3 = (PLINT *) 0 ;
7366 PLINT *arg4 = (PLINT *) 0 ;
7367 PLINT *arg5 = (PLINT *) 0 ;
7368 PLINT *arg6 = (PLINT *) 0 ;
7369 PLFLT temp1 ;
7370 int res1 = SWIG_TMPOBJ ;
7371 PLFLT temp2 ;
7372 int res2 = SWIG_TMPOBJ ;
7373 PLINT temp3 ;
7374 int res3 = SWIG_TMPOBJ ;
7375 PLINT temp4 ;
7376 int res4 = SWIG_TMPOBJ ;
7377 PLINT temp5 ;
7378 int res5 = SWIG_TMPOBJ ;
7379 PLINT temp6 ;
7380 int res6 = SWIG_TMPOBJ ;
7381
7382 arg1 = &temp1;
7383 arg2 = &temp2;
7384 arg3 = &temp3;
7385 arg4 = &temp4;
7386 arg5 = &temp5;
7387 arg6 = &temp6;
7388 (void)self;
7389 if (!SWIG_Python_UnpackTuple(args, "plgpage", 0, 0, 0)) SWIG_fail;
7390 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
7391 resultobj = SWIG_Py_Void();
7392 if (SWIG_IsTmpObj(res1)) {
7393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7394 } else {
7395 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7397 }
7398 if (SWIG_IsTmpObj(res2)) {
7399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7400 } else {
7401 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7403 }
7404 if (SWIG_IsTmpObj(res3)) {
7405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)), 1);
7406 } else {
7407 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags), 1);
7409 }
7410 if (SWIG_IsTmpObj(res4)) {
7411 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 1);
7412 } else {
7413 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 1);
7415 }
7416 if (SWIG_IsTmpObj(res5)) {
7417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 1);
7418 } else {
7419 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 1);
7421 }
7422 if (SWIG_IsTmpObj(res6)) {
7423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)), 1);
7424 } else {
7425 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags), 1);
7427 }
7428 return resultobj;
7429fail:
7430 return NULL;
7431}
7432
7433
7434SWIGINTERN PyObject *_wrap_plgra(PyObject *self, PyObject *args) {
7435 PyObject *resultobj = 0;
7436
7437 (void)self;
7438 if (!SWIG_Python_UnpackTuple(args, "plgra", 0, 0, 0)) SWIG_fail;
7439 plgra();
7440 resultobj = SWIG_Py_Void();
7441 return resultobj;
7442fail:
7443 return NULL;
7444}
7445
7446
7447SWIGINTERN PyObject *_wrap_plgriddata(PyObject *self, PyObject *args) {
7448 PyObject *resultobj = 0;
7449 PLFLT *arg1 = (PLFLT *) 0 ;
7450 PLFLT *arg2 = (PLFLT *) 0 ;
7451 PLFLT *arg3 = (PLFLT *) 0 ;
7452 PLINT arg4 ;
7453 PLFLT *arg5 = (PLFLT *) 0 ;
7454 PLINT arg6 ;
7455 PLFLT *arg7 = (PLFLT *) 0 ;
7456 PLINT arg8 ;
7457 PLFLT **arg9 = (PLFLT **) 0 ;
7458 PLINT arg10 ;
7459 PLFLT arg11 ;
7460 PyArrayObject *tmp1 = NULL ;
7461 PyArrayObject *tmp2 = NULL ;
7462 PyArrayObject *tmp3 = NULL ;
7463 PyArrayObject *tmp5 = NULL ;
7464 PyArrayObject *tmp7 = NULL ;
7465 PyObject *array7 = NULL ;
7466 int val10 ;
7467 int ecode10 = 0 ;
7468 double val11 ;
7469 int ecode11 = 0 ;
7470 PyObject *swig_obj[7] ;
7471
7472 (void)self;
7473 if (!SWIG_Python_UnpackTuple(args, "plgriddata", 7, 7, swig_obj)) SWIG_fail;
7474 {
7475 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7476 if ( tmp1 == NULL )
7477 return NULL;
7478 Alen = PyArray_DIMS( tmp1 )[0];
7479 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
7480 }
7481 {
7482 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
7483 if ( tmp2 == NULL )
7484 return NULL;
7485 if ( PyArray_DIMS( tmp2 )[0] != Alen )
7486 {
7487 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7488 return NULL;
7489 }
7490 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
7491 }
7492 {
7493 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
7494 if ( tmp3 == NULL )
7495 return NULL;
7496 if ( PyArray_DIMS( tmp3 )[0] != Alen )
7497 {
7498 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
7499 return NULL;
7500 }
7501 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
7502 arg4 = PyArray_DIMS( tmp3 )[0];
7503 }
7504 {
7505 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
7506 if ( tmp5 == NULL )
7507 return NULL;
7508 Xlen = PyArray_DIMS( tmp5 )[0];
7509 arg6 = Xlen;
7510 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
7511 }
7512 {
7513 int i, size;
7514 npy_intp dims[2];
7515 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
7516 if ( tmp7 == NULL )
7517 return NULL;
7518 Ylen = PyArray_DIMS( tmp7 )[0];
7519 arg8 = Ylen;
7520 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
7521 // Make created 2D array7 have dimensions from prior ArrayX in the argument
7522 // list and this ArrayY.
7523 dims[0] = Xlen;
7524 dims[1] = Ylen;
7525 array7 = PyArray_SimpleNew( 2, dims, NPY_PLFLT );
7526 if ( !array7 )
7527 return NULL;
7528 size = Ylen;
7529 arg9 = (PLFLT **) malloc( sizeof ( double * ) * (size_t) Xlen );
7530 for ( i = 0; i < Xlen; i++ )
7531 arg9[i] = ( (PLFLT *) PyArray_DATA( (PyArrayObject *) array7 ) + i * size );
7532 }
7533 ecode10 = SWIG_AsVal_int(swig_obj[5], &val10);
7534 if (!SWIG_IsOK(ecode10)) {
7535 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
7536 }
7537 arg10 = (PLINT)(val10);
7538 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
7539 if (!SWIG_IsOK(ecode11)) {
7540 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
7541 }
7542 arg11 = (PLFLT)(val11);
7543 plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
7544 resultobj = SWIG_Py_Void();
7545 {
7546 resultobj = SWIG_Python_AppendOutput(resultobj, array7, 1);
7547 }
7548 {
7549 Py_CLEAR( tmp1 );
7550 }
7551 {
7552 Py_CLEAR( tmp2 );
7553 }
7554 {
7555 Py_CLEAR( tmp3 );
7556 }
7557 {
7558 Py_CLEAR( tmp5 );
7559 }
7560 {
7561 Py_CLEAR( tmp7 );
7562 free( arg9 );
7563 }
7564 return resultobj;
7565fail:
7566 {
7567 Py_CLEAR( tmp1 );
7568 }
7569 {
7570 Py_CLEAR( tmp2 );
7571 }
7572 {
7573 Py_CLEAR( tmp3 );
7574 }
7575 {
7576 Py_CLEAR( tmp5 );
7577 }
7578 {
7579 Py_CLEAR( tmp7 );
7580 free( arg9 );
7581 }
7582 return NULL;
7583}
7584
7585
7586SWIGINTERN PyObject *_wrap_plgspa(PyObject *self, PyObject *args) {
7587 PyObject *resultobj = 0;
7588 PLFLT *arg1 = (PLFLT *) 0 ;
7589 PLFLT *arg2 = (PLFLT *) 0 ;
7590 PLFLT *arg3 = (PLFLT *) 0 ;
7591 PLFLT *arg4 = (PLFLT *) 0 ;
7592 PLFLT temp1 ;
7593 int res1 = SWIG_TMPOBJ ;
7594 PLFLT temp2 ;
7595 int res2 = SWIG_TMPOBJ ;
7596 PLFLT temp3 ;
7597 int res3 = SWIG_TMPOBJ ;
7598 PLFLT temp4 ;
7599 int res4 = SWIG_TMPOBJ ;
7600
7601 arg1 = &temp1;
7602 arg2 = &temp2;
7603 arg3 = &temp3;
7604 arg4 = &temp4;
7605 (void)self;
7606 if (!SWIG_Python_UnpackTuple(args, "plgspa", 0, 0, 0)) SWIG_fail;
7607 plgspa(arg1,arg2,arg3,arg4);
7608 resultobj = SWIG_Py_Void();
7609 if (SWIG_IsTmpObj(res1)) {
7610 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7611 } else {
7612 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7613 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7614 }
7615 if (SWIG_IsTmpObj(res2)) {
7616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7617 } else {
7618 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7619 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7620 }
7621 if (SWIG_IsTmpObj(res3)) {
7622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7623 } else {
7624 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7626 }
7627 if (SWIG_IsTmpObj(res4)) {
7628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7629 } else {
7630 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7632 }
7633 return resultobj;
7634fail:
7635 return NULL;
7636}
7637
7638
7639SWIGINTERN PyObject *_wrap_plgstrm(PyObject *self, PyObject *args) {
7640 PyObject *resultobj = 0;
7641 PLINT *arg1 = (PLINT *) 0 ;
7642 PLINT temp1 ;
7643 int res1 = SWIG_TMPOBJ ;
7644
7645 arg1 = &temp1;
7646 (void)self;
7647 if (!SWIG_Python_UnpackTuple(args, "plgstrm", 0, 0, 0)) SWIG_fail;
7648 plgstrm(arg1);
7649 resultobj = SWIG_Py_Void();
7650 if (SWIG_IsTmpObj(res1)) {
7651 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7652 } else {
7653 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7654 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7655 }
7656 return resultobj;
7657fail:
7658 return NULL;
7659}
7660
7661
7662SWIGINTERN PyObject *_wrap_plgver(PyObject *self, PyObject *args) {
7663 PyObject *resultobj = 0;
7664 char *arg1 = (char *) 0 ;
7665 char buff1[1000] ;
7666
7667 {
7668 arg1 = buff1;
7669 }
7670 (void)self;
7671 if (!SWIG_Python_UnpackTuple(args, "plgver", 0, 0, 0)) SWIG_fail;
7672 plgver(arg1);
7673 resultobj = SWIG_Py_Void();
7674 {
7675 PyObject *o = PyString_FromString( arg1 );
7676 resultobj = SWIG_Python_AppendOutput(resultobj, o, 1);
7677 }
7678 return resultobj;
7679fail:
7680 return NULL;
7681}
7682
7683
7684SWIGINTERN PyObject *_wrap_plgvpd(PyObject *self, PyObject *args) {
7685 PyObject *resultobj = 0;
7686 PLFLT *arg1 = (PLFLT *) 0 ;
7687 PLFLT *arg2 = (PLFLT *) 0 ;
7688 PLFLT *arg3 = (PLFLT *) 0 ;
7689 PLFLT *arg4 = (PLFLT *) 0 ;
7690 PLFLT temp1 ;
7691 int res1 = SWIG_TMPOBJ ;
7692 PLFLT temp2 ;
7693 int res2 = SWIG_TMPOBJ ;
7694 PLFLT temp3 ;
7695 int res3 = SWIG_TMPOBJ ;
7696 PLFLT temp4 ;
7697 int res4 = SWIG_TMPOBJ ;
7698
7699 arg1 = &temp1;
7700 arg2 = &temp2;
7701 arg3 = &temp3;
7702 arg4 = &temp4;
7703 (void)self;
7704 if (!SWIG_Python_UnpackTuple(args, "plgvpd", 0, 0, 0)) SWIG_fail;
7705 plgvpd(arg1,arg2,arg3,arg4);
7706 resultobj = SWIG_Py_Void();
7707 if (SWIG_IsTmpObj(res1)) {
7708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7709 } else {
7710 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7711 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7712 }
7713 if (SWIG_IsTmpObj(res2)) {
7714 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7715 } else {
7716 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7718 }
7719 if (SWIG_IsTmpObj(res3)) {
7720 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7721 } else {
7722 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7724 }
7725 if (SWIG_IsTmpObj(res4)) {
7726 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7727 } else {
7728 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7730 }
7731 return resultobj;
7732fail:
7733 return NULL;
7734}
7735
7736
7737SWIGINTERN PyObject *_wrap_plgvpw(PyObject *self, PyObject *args) {
7738 PyObject *resultobj = 0;
7739 PLFLT *arg1 = (PLFLT *) 0 ;
7740 PLFLT *arg2 = (PLFLT *) 0 ;
7741 PLFLT *arg3 = (PLFLT *) 0 ;
7742 PLFLT *arg4 = (PLFLT *) 0 ;
7743 PLFLT temp1 ;
7744 int res1 = SWIG_TMPOBJ ;
7745 PLFLT temp2 ;
7746 int res2 = SWIG_TMPOBJ ;
7747 PLFLT temp3 ;
7748 int res3 = SWIG_TMPOBJ ;
7749 PLFLT temp4 ;
7750 int res4 = SWIG_TMPOBJ ;
7751
7752 arg1 = &temp1;
7753 arg2 = &temp2;
7754 arg3 = &temp3;
7755 arg4 = &temp4;
7756 (void)self;
7757 if (!SWIG_Python_UnpackTuple(args, "plgvpw", 0, 0, 0)) SWIG_fail;
7758 plgvpw(arg1,arg2,arg3,arg4);
7759 resultobj = SWIG_Py_Void();
7760 if (SWIG_IsTmpObj(res1)) {
7761 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
7762 } else {
7763 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
7765 }
7766 if (SWIG_IsTmpObj(res2)) {
7767 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
7768 } else {
7769 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7770 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
7771 }
7772 if (SWIG_IsTmpObj(res3)) {
7773 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)), 1);
7774 } else {
7775 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7776 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags), 1);
7777 }
7778 if (SWIG_IsTmpObj(res4)) {
7779 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7780 } else {
7781 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7782 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
7783 }
7784 return resultobj;
7785fail:
7786 return NULL;
7787}
7788
7789
7790SWIGINTERN PyObject *_wrap_plgxax(PyObject *self, PyObject *args) {
7791 PyObject *resultobj = 0;
7792 PLINT *arg1 = (PLINT *) 0 ;
7793 PLINT *arg2 = (PLINT *) 0 ;
7794 PLINT temp1 ;
7795 int res1 = SWIG_TMPOBJ ;
7796 PLINT temp2 ;
7797 int res2 = SWIG_TMPOBJ ;
7798
7799 arg1 = &temp1;
7800 arg2 = &temp2;
7801 (void)self;
7802 if (!SWIG_Python_UnpackTuple(args, "plgxax", 0, 0, 0)) SWIG_fail;
7803 plgxax(arg1,arg2);
7804 resultobj = SWIG_Py_Void();
7805 if (SWIG_IsTmpObj(res1)) {
7806 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7807 } else {
7808 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7810 }
7811 if (SWIG_IsTmpObj(res2)) {
7812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7813 } else {
7814 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7816 }
7817 return resultobj;
7818fail:
7819 return NULL;
7820}
7821
7822
7823SWIGINTERN PyObject *_wrap_plgyax(PyObject *self, PyObject *args) {
7824 PyObject *resultobj = 0;
7825 PLINT *arg1 = (PLINT *) 0 ;
7826 PLINT *arg2 = (PLINT *) 0 ;
7827 PLINT temp1 ;
7828 int res1 = SWIG_TMPOBJ ;
7829 PLINT temp2 ;
7830 int res2 = SWIG_TMPOBJ ;
7831
7832 arg1 = &temp1;
7833 arg2 = &temp2;
7834 (void)self;
7835 if (!SWIG_Python_UnpackTuple(args, "plgyax", 0, 0, 0)) SWIG_fail;
7836 plgyax(arg1,arg2);
7837 resultobj = SWIG_Py_Void();
7838 if (SWIG_IsTmpObj(res1)) {
7839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7840 } else {
7841 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7843 }
7844 if (SWIG_IsTmpObj(res2)) {
7845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7846 } else {
7847 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7848 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7849 }
7850 return resultobj;
7851fail:
7852 return NULL;
7853}
7854
7855
7856SWIGINTERN PyObject *_wrap_plgzax(PyObject *self, PyObject *args) {
7857 PyObject *resultobj = 0;
7858 PLINT *arg1 = (PLINT *) 0 ;
7859 PLINT *arg2 = (PLINT *) 0 ;
7860 PLINT temp1 ;
7861 int res1 = SWIG_TMPOBJ ;
7862 PLINT temp2 ;
7863 int res2 = SWIG_TMPOBJ ;
7864
7865 arg1 = &temp1;
7866 arg2 = &temp2;
7867 (void)self;
7868 if (!SWIG_Python_UnpackTuple(args, "plgzax", 0, 0, 0)) SWIG_fail;
7869 plgzax(arg1,arg2);
7870 resultobj = SWIG_Py_Void();
7871 if (SWIG_IsTmpObj(res1)) {
7872 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
7873 } else {
7874 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7875 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
7876 }
7877 if (SWIG_IsTmpObj(res2)) {
7878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
7879 } else {
7880 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
7882 }
7883 return resultobj;
7884fail:
7885 return NULL;
7886}
7887
7888
7889SWIGINTERN PyObject *_wrap_plhist(PyObject *self, PyObject *args) {
7890 PyObject *resultobj = 0;
7891 PLINT arg1 ;
7892 PLFLT *arg2 = (PLFLT *) 0 ;
7893 PLFLT arg3 ;
7894 PLFLT arg4 ;
7895 PLINT arg5 ;
7896 PLINT arg6 ;
7897 PyArrayObject *tmp1 = NULL ;
7898 double val3 ;
7899 int ecode3 = 0 ;
7900 double val4 ;
7901 int ecode4 = 0 ;
7902 int val5 ;
7903 int ecode5 = 0 ;
7904 int val6 ;
7905 int ecode6 = 0 ;
7906 PyObject *swig_obj[5] ;
7907
7908 (void)self;
7909 if (!SWIG_Python_UnpackTuple(args, "plhist", 5, 5, swig_obj)) SWIG_fail;
7910 {
7911 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
7912 if ( tmp1 == NULL )
7913 return NULL;
7914 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
7915 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
7916 }
7917 ecode3 = SWIG_AsVal_double(swig_obj[1], &val3);
7918 if (!SWIG_IsOK(ecode3)) {
7919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
7920 }
7921 arg3 = (PLFLT)(val3);
7922 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
7923 if (!SWIG_IsOK(ecode4)) {
7924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
7925 }
7926 arg4 = (PLFLT)(val4);
7927 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
7928 if (!SWIG_IsOK(ecode5)) {
7929 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
7930 }
7931 arg5 = (PLINT)(val5);
7932 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
7933 if (!SWIG_IsOK(ecode6)) {
7934 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
7935 }
7936 arg6 = (PLINT)(val6);
7937 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
7938 resultobj = SWIG_Py_Void();
7939 {
7940 Py_CLEAR( tmp1 );
7941 }
7942 return resultobj;
7943fail:
7944 {
7945 Py_CLEAR( tmp1 );
7946 }
7947 return NULL;
7948}
7949
7950
7951SWIGINTERN PyObject *_wrap_plhlsrgb(PyObject *self, PyObject *args) {
7952 PyObject *resultobj = 0;
7953 PLFLT arg1 ;
7954 PLFLT arg2 ;
7955 PLFLT arg3 ;
7956 PLFLT *arg4 = (PLFLT *) 0 ;
7957 PLFLT *arg5 = (PLFLT *) 0 ;
7958 PLFLT *arg6 = (PLFLT *) 0 ;
7959 double val1 ;
7960 int ecode1 = 0 ;
7961 double val2 ;
7962 int ecode2 = 0 ;
7963 double val3 ;
7964 int ecode3 = 0 ;
7965 PLFLT temp4 ;
7966 int res4 = SWIG_TMPOBJ ;
7967 PLFLT temp5 ;
7968 int res5 = SWIG_TMPOBJ ;
7969 PLFLT temp6 ;
7970 int res6 = SWIG_TMPOBJ ;
7971 PyObject *swig_obj[3] ;
7972
7973 arg4 = &temp4;
7974 arg5 = &temp5;
7975 arg6 = &temp6;
7976 (void)self;
7977 if (!SWIG_Python_UnpackTuple(args, "plhlsrgb", 3, 3, swig_obj)) SWIG_fail;
7978 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
7979 if (!SWIG_IsOK(ecode1)) {
7980 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
7981 }
7982 arg1 = (PLFLT)(val1);
7983 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
7984 if (!SWIG_IsOK(ecode2)) {
7985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
7986 }
7987 arg2 = (PLFLT)(val2);
7988 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
7989 if (!SWIG_IsOK(ecode3)) {
7990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
7991 }
7992 arg3 = (PLFLT)(val3);
7993 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
7994 resultobj = SWIG_Py_Void();
7995 if (SWIG_IsTmpObj(res4)) {
7996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
7997 } else {
7998 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
8000 }
8001 if (SWIG_IsTmpObj(res5)) {
8002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
8003 } else {
8004 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
8006 }
8007 if (SWIG_IsTmpObj(res6)) {
8008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 1);
8009 } else {
8010 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 1);
8012 }
8013 return resultobj;
8014fail:
8015 return NULL;
8016}
8017
8018
8019SWIGINTERN PyObject *_wrap_plinit(PyObject *self, PyObject *args) {
8020 PyObject *resultobj = 0;
8021
8022 (void)self;
8023 if (!SWIG_Python_UnpackTuple(args, "plinit", 0, 0, 0)) SWIG_fail;
8024 plinit();
8025 resultobj = SWIG_Py_Void();
8026 return resultobj;
8027fail:
8028 return NULL;
8029}
8030
8031
8032SWIGINTERN PyObject *_wrap_pljoin(PyObject *self, PyObject *args) {
8033 PyObject *resultobj = 0;
8034 PLFLT arg1 ;
8035 PLFLT arg2 ;
8036 PLFLT arg3 ;
8037 PLFLT arg4 ;
8038 double val1 ;
8039 int ecode1 = 0 ;
8040 double val2 ;
8041 int ecode2 = 0 ;
8042 double val3 ;
8043 int ecode3 = 0 ;
8044 double val4 ;
8045 int ecode4 = 0 ;
8046 PyObject *swig_obj[4] ;
8047
8048 (void)self;
8049 if (!SWIG_Python_UnpackTuple(args, "pljoin", 4, 4, swig_obj)) SWIG_fail;
8050 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8051 if (!SWIG_IsOK(ecode1)) {
8052 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
8053 }
8054 arg1 = (PLFLT)(val1);
8055 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8056 if (!SWIG_IsOK(ecode2)) {
8057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
8058 }
8059 arg2 = (PLFLT)(val2);
8060 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8061 if (!SWIG_IsOK(ecode3)) {
8062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
8063 }
8064 arg3 = (PLFLT)(val3);
8065 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
8066 if (!SWIG_IsOK(ecode4)) {
8067 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
8068 }
8069 arg4 = (PLFLT)(val4);
8070 pljoin(arg1,arg2,arg3,arg4);
8071 resultobj = SWIG_Py_Void();
8072 return resultobj;
8073fail:
8074 return NULL;
8075}
8076
8077
8078SWIGINTERN PyObject *_wrap_pllab(PyObject *self, PyObject *args) {
8079 PyObject *resultobj = 0;
8080 char *arg1 = (char *) 0 ;
8081 char *arg2 = (char *) 0 ;
8082 char *arg3 = (char *) 0 ;
8083 int res1 ;
8084 char *buf1 = 0 ;
8085 int alloc1 = 0 ;
8086 int res2 ;
8087 char *buf2 = 0 ;
8088 int alloc2 = 0 ;
8089 int res3 ;
8090 char *buf3 = 0 ;
8091 int alloc3 = 0 ;
8092 PyObject *swig_obj[3] ;
8093
8094 (void)self;
8095 if (!SWIG_Python_UnpackTuple(args, "pllab", 3, 3, swig_obj)) SWIG_fail;
8096 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
8097 if (!SWIG_IsOK(res1)) {
8098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
8099 }
8100 arg1 = (char *)(buf1);
8101 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
8102 if (!SWIG_IsOK(res2)) {
8103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
8104 }
8105 arg2 = (char *)(buf2);
8106 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
8107 if (!SWIG_IsOK(res3)) {
8108 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
8109 }
8110 arg3 = (char *)(buf3);
8111 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
8112 resultobj = SWIG_Py_Void();
8113 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8114 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8115 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8116 return resultobj;
8117fail:
8118 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8119 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8120 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
8121 return NULL;
8122}
8123
8124
8125SWIGINTERN PyObject *_wrap_pllegend(PyObject *self, PyObject *args) {
8126 PyObject *resultobj = 0;
8127 PLFLT *arg1 = (PLFLT *) 0 ;
8128 PLFLT *arg2 = (PLFLT *) 0 ;
8129 PLINT arg3 ;
8130 PLINT arg4 ;
8131 PLFLT arg5 ;
8132 PLFLT arg6 ;
8133 PLFLT arg7 ;
8134 PLINT arg8 ;
8135 PLINT arg9 ;
8136 PLINT arg10 ;
8137 PLINT arg11 ;
8138 PLINT arg12 ;
8139 PLINT arg13 ;
8140 PLINT *arg14 = (PLINT *) 0 ;
8141 PLFLT arg15 ;
8142 PLFLT arg16 ;
8143 PLFLT arg17 ;
8144 PLFLT arg18 ;
8145 PLINT *arg19 = (PLINT *) 0 ;
8146 char **arg20 = (char **) 0 ;
8147 PLINT *arg21 = (PLINT *) 0 ;
8148 PLINT *arg22 = (PLINT *) 0 ;
8149 PLFLT *arg23 = (PLFLT *) 0 ;
8150 PLFLT *arg24 = (PLFLT *) 0 ;
8151 PLINT *arg25 = (PLINT *) 0 ;
8152 PLINT *arg26 = (PLINT *) 0 ;
8153 PLFLT *arg27 = (PLFLT *) 0 ;
8154 PLINT *arg28 = (PLINT *) 0 ;
8155 PLFLT *arg29 = (PLFLT *) 0 ;
8156 PLINT *arg30 = (PLINT *) 0 ;
8157 char **arg31 = (char **) 0 ;
8158 PLFLT temp1 ;
8159 int res1 = SWIG_TMPOBJ ;
8160 PLFLT temp2 ;
8161 int res2 = SWIG_TMPOBJ ;
8162 int val3 ;
8163 int ecode3 = 0 ;
8164 int val4 ;
8165 int ecode4 = 0 ;
8166 double val5 ;
8167 int ecode5 = 0 ;
8168 double val6 ;
8169 int ecode6 = 0 ;
8170 double val7 ;
8171 int ecode7 = 0 ;
8172 int val8 ;
8173 int ecode8 = 0 ;
8174 int val9 ;
8175 int ecode9 = 0 ;
8176 int val10 ;
8177 int ecode10 = 0 ;
8178 int val11 ;
8179 int ecode11 = 0 ;
8180 int val12 ;
8181 int ecode12 = 0 ;
8182 PyArrayObject *tmp13 = NULL ;
8183 double val15 ;
8184 int ecode15 = 0 ;
8185 double val16 ;
8186 int ecode16 = 0 ;
8187 double val17 ;
8188 int ecode17 = 0 ;
8189 double val18 ;
8190 int ecode18 = 0 ;
8191 PyArrayObject *tmp19 = NULL ;
8192 PyArrayObject *tmp20 = NULL ;
8193 PyArrayObject *tmp21 = NULL ;
8194 PyArrayObject *tmp22 = NULL ;
8195 PyArrayObject *tmp23 = NULL ;
8196 PyArrayObject *tmp24 = NULL ;
8197 PyArrayObject *tmp25 = NULL ;
8198 PyArrayObject *tmp26 = NULL ;
8199 PyArrayObject *tmp27 = NULL ;
8200 PyArrayObject *tmp28 = NULL ;
8201 PyArrayObject *tmp29 = NULL ;
8202 PyArrayObject *tmp30 = NULL ;
8203 PyArrayObject *tmp31 = NULL ;
8204 PyObject *swig_obj[28] ;
8205
8206 arg1 = &temp1;
8207 arg2 = &temp2;
8208 (void)self;
8209 if (!SWIG_Python_UnpackTuple(args, "pllegend", 28, 28, swig_obj)) SWIG_fail;
8210 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8211 if (!SWIG_IsOK(ecode3)) {
8212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
8213 }
8214 arg3 = (PLINT)(val3);
8215 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8216 if (!SWIG_IsOK(ecode4)) {
8217 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
8218 }
8219 arg4 = (PLINT)(val4);
8220 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8221 if (!SWIG_IsOK(ecode5)) {
8222 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
8223 }
8224 arg5 = (PLFLT)(val5);
8225 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8226 if (!SWIG_IsOK(ecode6)) {
8227 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
8228 }
8229 arg6 = (PLFLT)(val6);
8230 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8231 if (!SWIG_IsOK(ecode7)) {
8232 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
8233 }
8234 arg7 = (PLFLT)(val7);
8235 ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
8236 if (!SWIG_IsOK(ecode8)) {
8237 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
8238 }
8239 arg8 = (PLINT)(val8);
8240 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8241 if (!SWIG_IsOK(ecode9)) {
8242 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
8243 }
8244 arg9 = (PLINT)(val9);
8245 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8246 if (!SWIG_IsOK(ecode10)) {
8247 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
8248 }
8249 arg10 = (PLINT)(val10);
8250 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8251 if (!SWIG_IsOK(ecode11)) {
8252 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
8253 }
8254 arg11 = (PLINT)(val11);
8255 ecode12 = SWIG_AsVal_int(swig_obj[9], &val12);
8256 if (!SWIG_IsOK(ecode12)) {
8257 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
8258 }
8259 arg12 = (PLINT)(val12);
8260 {
8261 tmp13 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[10], NPY_PLINT, 1, 1 );
8262 if ( tmp13 == NULL )
8263 return NULL;
8264 arg13 = Alen = PyArray_DIMS( tmp13 )[0];
8265 arg14 = (PLINT *) PyArray_DATA( tmp13 );
8266 }
8267 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
8268 if (!SWIG_IsOK(ecode15)) {
8269 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
8270 }
8271 arg15 = (PLFLT)(val15);
8272 ecode16 = SWIG_AsVal_double(swig_obj[12], &val16);
8273 if (!SWIG_IsOK(ecode16)) {
8274 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
8275 }
8276 arg16 = (PLFLT)(val16);
8277 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
8278 if (!SWIG_IsOK(ecode17)) {
8279 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
8280 }
8281 arg17 = (PLFLT)(val17);
8282 ecode18 = SWIG_AsVal_double(swig_obj[14], &val18);
8283 if (!SWIG_IsOK(ecode18)) {
8284 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
8285 }
8286 arg18 = (PLFLT)(val18);
8287 {
8288 tmp19 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[15], NPY_PLINT, 1, 1 );
8289 if ( tmp19 == NULL )
8290 return NULL;
8291 if ( PyArray_DIMS( tmp19 )[0] != Alen )
8292 {
8293 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8294 return NULL;
8295 }
8296 arg19 = (PLINT *) PyArray_DATA( tmp19 );
8297 }
8298 {
8299 int i;
8300 tmp20 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[16], NPY_STRING, 1, 1 );
8301 if ( tmp20 == NULL )
8302 return NULL;
8303 if ( PyArray_DIMS( tmp20 )[0] != Alen )
8304 {
8305 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8306 return NULL;
8307 }
8308 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8309 for ( i = 0; i < Alen; i++ )
8310 {
8311 arg20[i] = (char *) PyArray_DATA( tmp20 ) + i * PyArray_STRIDES( tmp20 )[0];
8312 if ( arg20[i] == NULL )
8313 {
8314 free( arg20 );
8315 return NULL;
8316 }
8317 }
8318 }
8319 {
8320 tmp21 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8321 if ( tmp21 == NULL )
8322 return NULL;
8323 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8324 {
8325 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8326 return NULL;
8327 }
8328 arg21 = (PLINT *) PyArray_DATA( tmp21 );
8329 }
8330 {
8331 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8332 if ( tmp22 == NULL )
8333 return NULL;
8334 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8335 {
8336 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8337 return NULL;
8338 }
8339 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8340 }
8341 {
8342 if ( swig_obj[19] != Py_None )
8343 {
8344 tmp23 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 1, 1 );
8345 if ( tmp23 == NULL )
8346 return NULL;
8347 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8348 {
8349 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8350 return NULL;
8351 }
8352 arg23 = (PLFLT *) PyArray_DATA( tmp23 );
8353 }
8354 else
8355 {
8356 arg23 = NULL;
8357 }
8358 }
8359 {
8360 if ( swig_obj[20] != Py_None )
8361 {
8362 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[20], NPY_PLFLT, 1, 1 );
8363 if ( tmp24 == NULL )
8364 return NULL;
8365 if ( PyArray_DIMS( tmp24 )[0] != Alen )
8366 {
8367 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8368 return NULL;
8369 }
8370 arg24 = (PLFLT *) PyArray_DATA( tmp24 );
8371 }
8372 else
8373 {
8374 arg24 = NULL;
8375 }
8376 }
8377 {
8378 tmp25 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[21], NPY_PLINT, 1, 1 );
8379 if ( tmp25 == NULL )
8380 return NULL;
8381 if ( PyArray_DIMS( tmp25 )[0] != Alen )
8382 {
8383 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8384 return NULL;
8385 }
8386 arg25 = (PLINT *) PyArray_DATA( tmp25 );
8387 }
8388 {
8389 tmp26 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[22], NPY_PLINT, 1, 1 );
8390 if ( tmp26 == NULL )
8391 return NULL;
8392 if ( PyArray_DIMS( tmp26 )[0] != Alen )
8393 {
8394 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8395 return NULL;
8396 }
8397 arg26 = (PLINT *) PyArray_DATA( tmp26 );
8398 }
8399 {
8400 if ( swig_obj[23] != Py_None )
8401 {
8402 tmp27 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[23], NPY_PLFLT, 1, 1 );
8403 if ( tmp27 == NULL )
8404 return NULL;
8405 if ( PyArray_DIMS( tmp27 )[0] != Alen )
8406 {
8407 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8408 return NULL;
8409 }
8410 arg27 = (PLFLT *) PyArray_DATA( tmp27 );
8411 }
8412 else
8413 {
8414 arg27 = NULL;
8415 }
8416 }
8417 {
8418 tmp28 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[24], NPY_PLINT, 1, 1 );
8419 if ( tmp28 == NULL )
8420 return NULL;
8421 if ( PyArray_DIMS( tmp28 )[0] != Alen )
8422 {
8423 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8424 return NULL;
8425 }
8426 arg28 = (PLINT *) PyArray_DATA( tmp28 );
8427 }
8428 {
8429 if ( swig_obj[25] != Py_None )
8430 {
8431 tmp29 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[25], NPY_PLFLT, 1, 1 );
8432 if ( tmp29 == NULL )
8433 return NULL;
8434 if ( PyArray_DIMS( tmp29 )[0] != Alen )
8435 {
8436 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8437 return NULL;
8438 }
8439 arg29 = (PLFLT *) PyArray_DATA( tmp29 );
8440 }
8441 else
8442 {
8443 arg29 = NULL;
8444 }
8445 }
8446 {
8447 tmp30 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[26], NPY_PLINT, 1, 1 );
8448 if ( tmp30 == NULL )
8449 return NULL;
8450 if ( PyArray_DIMS( tmp30 )[0] != Alen )
8451 {
8452 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8453 return NULL;
8454 }
8455 arg30 = (PLINT *) PyArray_DATA( tmp30 );
8456 }
8457 {
8458 int i;
8459 tmp31 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[27], NPY_STRING, 1, 1 );
8460 if ( tmp31 == NULL )
8461 return NULL;
8462 if ( PyArray_DIMS( tmp31 )[0] != Alen )
8463 {
8464 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8465 return NULL;
8466 }
8467 arg31 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8468 for ( i = 0; i < Alen; i++ )
8469 {
8470 arg31[i] = (char *) PyArray_DATA( tmp31 ) + i * PyArray_STRIDES( tmp31 )[0];
8471 if ( arg31[i] == NULL )
8472 {
8473 free( arg31 );
8474 return NULL;
8475 }
8476 }
8477 }
8478 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);
8479 resultobj = SWIG_Py_Void();
8480 if (SWIG_IsTmpObj(res1)) {
8481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
8482 } else {
8483 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8484 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
8485 }
8486 if (SWIG_IsTmpObj(res2)) {
8487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
8488 } else {
8489 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
8491 }
8492 {
8493 Py_CLEAR( tmp13 );
8494 }
8495 {
8496 Py_CLEAR( tmp19 );
8497 }
8498 {
8499 Py_CLEAR( tmp20 ); free( arg20 );
8500 }
8501 {
8502 Py_CLEAR( tmp21 );
8503 }
8504 {
8505 Py_CLEAR( tmp22 );
8506 }
8507 {
8508 Py_CLEAR( tmp23 );
8509 }
8510 {
8511 Py_CLEAR( tmp24 );
8512 }
8513 {
8514 Py_CLEAR( tmp25 );
8515 }
8516 {
8517 Py_CLEAR( tmp26 );
8518 }
8519 {
8520 Py_CLEAR( tmp27 );
8521 }
8522 {
8523 Py_CLEAR( tmp28 );
8524 }
8525 {
8526 Py_CLEAR( tmp29 );
8527 }
8528 {
8529 Py_CLEAR( tmp30 );
8530 }
8531 {
8532 Py_CLEAR( tmp31 ); free( arg31 );
8533 }
8534 return resultobj;
8535fail:
8536 {
8537 Py_CLEAR( tmp13 );
8538 }
8539 {
8540 Py_CLEAR( tmp19 );
8541 }
8542 {
8543 Py_CLEAR( tmp20 ); free( arg20 );
8544 }
8545 {
8546 Py_CLEAR( tmp21 );
8547 }
8548 {
8549 Py_CLEAR( tmp22 );
8550 }
8551 {
8552 Py_CLEAR( tmp23 );
8553 }
8554 {
8555 Py_CLEAR( tmp24 );
8556 }
8557 {
8558 Py_CLEAR( tmp25 );
8559 }
8560 {
8561 Py_CLEAR( tmp26 );
8562 }
8563 {
8564 Py_CLEAR( tmp27 );
8565 }
8566 {
8567 Py_CLEAR( tmp28 );
8568 }
8569 {
8570 Py_CLEAR( tmp29 );
8571 }
8572 {
8573 Py_CLEAR( tmp30 );
8574 }
8575 {
8576 Py_CLEAR( tmp31 ); free( arg31 );
8577 }
8578 return NULL;
8579}
8580
8581
8582SWIGINTERN PyObject *_wrap_plcolorbar(PyObject *self, PyObject *args) {
8583 PyObject *resultobj = 0;
8584 PLFLT *arg1 = (PLFLT *) 0 ;
8585 PLFLT *arg2 = (PLFLT *) 0 ;
8586 PLINT arg3 ;
8587 PLINT arg4 ;
8588 PLFLT arg5 ;
8589 PLFLT arg6 ;
8590 PLFLT arg7 ;
8591 PLFLT arg8 ;
8592 PLINT arg9 ;
8593 PLINT arg10 ;
8594 PLINT arg11 ;
8595 PLFLT arg12 ;
8596 PLFLT arg13 ;
8597 PLINT arg14 ;
8598 PLFLT arg15 ;
8599 PLINT arg16 ;
8600 PLINT *arg17 = (PLINT *) 0 ;
8601 char **arg18 = (char **) 0 ;
8602 PLINT arg19 ;
8603 char **arg20 = (char **) 0 ;
8604 PLFLT *arg21 = (PLFLT *) 0 ;
8605 PLINT *arg22 = (PLINT *) 0 ;
8606 PLINT *arg23 = (PLINT *) 0 ;
8607 PLFLT **arg24 = (PLFLT **) 0 ;
8608 PLFLT temp1 ;
8609 int res1 = SWIG_TMPOBJ ;
8610 PLFLT temp2 ;
8611 int res2 = SWIG_TMPOBJ ;
8612 int val3 ;
8613 int ecode3 = 0 ;
8614 int val4 ;
8615 int ecode4 = 0 ;
8616 double val5 ;
8617 int ecode5 = 0 ;
8618 double val6 ;
8619 int ecode6 = 0 ;
8620 double val7 ;
8621 int ecode7 = 0 ;
8622 double val8 ;
8623 int ecode8 = 0 ;
8624 int val9 ;
8625 int ecode9 = 0 ;
8626 int val10 ;
8627 int ecode10 = 0 ;
8628 int val11 ;
8629 int ecode11 = 0 ;
8630 double val12 ;
8631 int ecode12 = 0 ;
8632 double val13 ;
8633 int ecode13 = 0 ;
8634 int val14 ;
8635 int ecode14 = 0 ;
8636 double val15 ;
8637 int ecode15 = 0 ;
8638 PyArrayObject *tmp16 = NULL ;
8639 PyArrayObject *tmp18 = NULL ;
8640 PyArrayObject *tmp19 = NULL ;
8641 PyArrayObject *tmp21 = NULL ;
8642 PyArrayObject *tmp22 = NULL ;
8643 PyArrayObject *tmp23 = NULL ;
8644 PyArrayObject *tmp24 = NULL ;
8645 PyObject *swig_obj[20] ;
8646
8647 arg1 = &temp1;
8648 arg2 = &temp2;
8649 (void)self;
8650 if (!SWIG_Python_UnpackTuple(args, "plcolorbar", 20, 20, swig_obj)) SWIG_fail;
8651 ecode3 = SWIG_AsVal_int(swig_obj[0], &val3);
8652 if (!SWIG_IsOK(ecode3)) {
8653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
8654 }
8655 arg3 = (PLINT)(val3);
8656 ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
8657 if (!SWIG_IsOK(ecode4)) {
8658 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
8659 }
8660 arg4 = (PLINT)(val4);
8661 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
8662 if (!SWIG_IsOK(ecode5)) {
8663 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
8664 }
8665 arg5 = (PLFLT)(val5);
8666 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
8667 if (!SWIG_IsOK(ecode6)) {
8668 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
8669 }
8670 arg6 = (PLFLT)(val6);
8671 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
8672 if (!SWIG_IsOK(ecode7)) {
8673 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
8674 }
8675 arg7 = (PLFLT)(val7);
8676 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
8677 if (!SWIG_IsOK(ecode8)) {
8678 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
8679 }
8680 arg8 = (PLFLT)(val8);
8681 ecode9 = SWIG_AsVal_int(swig_obj[6], &val9);
8682 if (!SWIG_IsOK(ecode9)) {
8683 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
8684 }
8685 arg9 = (PLINT)(val9);
8686 ecode10 = SWIG_AsVal_int(swig_obj[7], &val10);
8687 if (!SWIG_IsOK(ecode10)) {
8688 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
8689 }
8690 arg10 = (PLINT)(val10);
8691 ecode11 = SWIG_AsVal_int(swig_obj[8], &val11);
8692 if (!SWIG_IsOK(ecode11)) {
8693 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
8694 }
8695 arg11 = (PLINT)(val11);
8696 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
8697 if (!SWIG_IsOK(ecode12)) {
8698 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
8699 }
8700 arg12 = (PLFLT)(val12);
8701 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
8702 if (!SWIG_IsOK(ecode13)) {
8703 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
8704 }
8705 arg13 = (PLFLT)(val13);
8706 ecode14 = SWIG_AsVal_int(swig_obj[11], &val14);
8707 if (!SWIG_IsOK(ecode14)) {
8708 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
8709 }
8710 arg14 = (PLINT)(val14);
8711 ecode15 = SWIG_AsVal_double(swig_obj[12], &val15);
8712 if (!SWIG_IsOK(ecode15)) {
8713 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
8714 }
8715 arg15 = (PLFLT)(val15);
8716 {
8717 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
8718 if ( tmp16 == NULL )
8719 return NULL;
8720 arg16 = Alen = PyArray_DIMS( tmp16 )[0];
8721 arg17 = (PLINT *) PyArray_DATA( tmp16 );
8722 }
8723 {
8724 int i;
8725 tmp18 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[14], NPY_STRING, 1, 1 );
8726 if ( tmp18 == NULL )
8727 return NULL;
8728 if ( PyArray_DIMS( tmp18 )[0] != Alen )
8729 {
8730 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8731 return NULL;
8732 }
8733 arg18 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8734 for ( i = 0; i < Alen; i++ )
8735 {
8736 arg18[i] = (char *) PyArray_DATA( tmp18 ) + i * PyArray_STRIDES( tmp18 )[0];
8737 if ( arg18[i] == NULL )
8738 {
8739 free( arg18 );
8740 return NULL;
8741 }
8742 }
8743 }
8744 {
8745 int i;
8746 tmp19 = (PyArrayObject *) PyArray_ContiguousFromObject( swig_obj[15], NPY_STRING, 1, 1 );
8747 if ( tmp19 == NULL )
8748 return NULL;
8749 Alen = PyArray_DIMS( tmp19 )[0];
8750 arg19 = Alen;
8751 arg20 = (char **) malloc( sizeof ( char* ) * (size_t) Alen );
8752 for ( i = 0; i < Alen; i++ )
8753 {
8754 arg20[i] = (char *) PyArray_DATA( tmp19 ) + i * PyArray_STRIDES( tmp19 )[0];
8755 if ( arg20[i] == NULL )
8756 {
8757 free( arg20 );
8758 return NULL;
8759 }
8760 }
8761 }
8762 {
8763 tmp21 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[16], NPY_PLFLT, 1, 1 );
8764 if ( tmp21 == NULL )
8765 return NULL;
8766 if ( PyArray_DIMS( tmp21 )[0] != Alen )
8767 {
8768 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8769 return NULL;
8770 }
8771 arg21 = (PLFLT *) PyArray_DATA( tmp21 );
8772 }
8773 {
8774 tmp22 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[17], NPY_PLINT, 1, 1 );
8775 if ( tmp22 == NULL )
8776 return NULL;
8777 if ( PyArray_DIMS( tmp22 )[0] != Alen )
8778 {
8779 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8780 return NULL;
8781 }
8782 arg22 = (PLINT *) PyArray_DATA( tmp22 );
8783 }
8784 {
8785 int i;
8786 tmp23 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[18], NPY_PLINT, 1, 1 );
8787 if ( tmp23 == NULL )
8788 return NULL;
8789 if ( PyArray_DIMS( tmp23 )[0] != Alen )
8790 {
8791 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8792 return NULL;
8793 }
8794 Xlen = PyArray_DIMS( tmp23 )[0];
8795 arg23 = (PLINT *) PyArray_DATA( tmp23 );
8796 Ylen = -1;
8797 for ( i = 0; i < Xlen; i++ )
8798 if ( arg23[i] > Ylen )
8799 Ylen = arg23[i];
8800 }
8801 {
8802 int i, size;
8803 tmp24 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[19], NPY_PLFLT, 2, 2 );
8804 if ( tmp24 == NULL )
8805 return NULL;
8806 if ( PyArray_DIMS( tmp24 )[0] != Xlen || PyArray_DIMS( tmp24 )[1] != Ylen )
8807 {
8808 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
8809 return NULL;
8810 }
8811 size = Ylen;
8812 arg24 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
8813 for ( i = 0; i < Xlen; i++ )
8814 arg24[i] = ( (PLFLT *) PyArray_DATA( tmp24 ) + i * size );
8815 }
8816 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);
8817 resultobj = SWIG_Py_Void();
8818 if (SWIG_IsTmpObj(res1)) {
8819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
8820 } else {
8821 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
8823 }
8824 if (SWIG_IsTmpObj(res2)) {
8825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
8826 } else {
8827 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
8829 }
8830 {
8831 Py_CLEAR( tmp16 );
8832 }
8833 {
8834 Py_CLEAR( tmp18 ); free( arg18 );
8835 }
8836 {
8837 Py_CLEAR( tmp19 ); free( arg20 );
8838 }
8839 {
8840 Py_CLEAR( tmp21 );
8841 }
8842 {
8843 Py_CLEAR( tmp22 );
8844 }
8845 {
8846 Py_CLEAR( tmp23 );
8847 }
8848 {
8849 Py_CLEAR( tmp24 );
8850 free( arg24 );
8851 }
8852 return resultobj;
8853fail:
8854 {
8855 Py_CLEAR( tmp16 );
8856 }
8857 {
8858 Py_CLEAR( tmp18 ); free( arg18 );
8859 }
8860 {
8861 Py_CLEAR( tmp19 ); free( arg20 );
8862 }
8863 {
8864 Py_CLEAR( tmp21 );
8865 }
8866 {
8867 Py_CLEAR( tmp22 );
8868 }
8869 {
8870 Py_CLEAR( tmp23 );
8871 }
8872 {
8873 Py_CLEAR( tmp24 );
8874 free( arg24 );
8875 }
8876 return NULL;
8877}
8878
8879
8880SWIGINTERN PyObject *_wrap_pllightsource(PyObject *self, PyObject *args) {
8881 PyObject *resultobj = 0;
8882 PLFLT arg1 ;
8883 PLFLT arg2 ;
8884 PLFLT arg3 ;
8885 double val1 ;
8886 int ecode1 = 0 ;
8887 double val2 ;
8888 int ecode2 = 0 ;
8889 double val3 ;
8890 int ecode3 = 0 ;
8891 PyObject *swig_obj[3] ;
8892
8893 (void)self;
8894 if (!SWIG_Python_UnpackTuple(args, "pllightsource", 3, 3, swig_obj)) SWIG_fail;
8895 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
8896 if (!SWIG_IsOK(ecode1)) {
8897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
8898 }
8899 arg1 = (PLFLT)(val1);
8900 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8901 if (!SWIG_IsOK(ecode2)) {
8902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
8903 }
8904 arg2 = (PLFLT)(val2);
8905 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
8906 if (!SWIG_IsOK(ecode3)) {
8907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
8908 }
8909 arg3 = (PLFLT)(val3);
8910 pllightsource(arg1,arg2,arg3);
8911 resultobj = SWIG_Py_Void();
8912 return resultobj;
8913fail:
8914 return NULL;
8915}
8916
8917
8918SWIGINTERN PyObject *_wrap_plline(PyObject *self, PyObject *args) {
8919 PyObject *resultobj = 0;
8920 PLINT arg1 ;
8921 PLFLT *arg2 = (PLFLT *) 0 ;
8922 PLFLT *arg3 = (PLFLT *) 0 ;
8923 PyArrayObject *tmp1 = NULL ;
8924 PyArrayObject *tmp3 = NULL ;
8925 PyObject *swig_obj[2] ;
8926
8927 (void)self;
8928 if (!SWIG_Python_UnpackTuple(args, "plline", 2, 2, swig_obj)) SWIG_fail;
8929 {
8930 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8931 if ( tmp1 == NULL )
8932 return NULL;
8933 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8934 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8935 }
8936 {
8937 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8938 if ( tmp3 == NULL )
8939 return NULL;
8940 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8941 {
8942 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8943 return NULL;
8944 }
8945 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8946 }
8947 plline(arg1,(double const *)arg2,(double const *)arg3);
8948 resultobj = SWIG_Py_Void();
8949 {
8950 Py_CLEAR( tmp1 );
8951 }
8952 {
8953 Py_CLEAR( tmp3 );
8954 }
8955 return resultobj;
8956fail:
8957 {
8958 Py_CLEAR( tmp1 );
8959 }
8960 {
8961 Py_CLEAR( tmp3 );
8962 }
8963 return NULL;
8964}
8965
8966
8967SWIGINTERN PyObject *_wrap_plline3(PyObject *self, PyObject *args) {
8968 PyObject *resultobj = 0;
8969 PLINT arg1 ;
8970 PLFLT *arg2 = (PLFLT *) 0 ;
8971 PLFLT *arg3 = (PLFLT *) 0 ;
8972 PLFLT *arg4 = (PLFLT *) 0 ;
8973 PyArrayObject *tmp1 = NULL ;
8974 PyArrayObject *tmp3 = NULL ;
8975 PyArrayObject *tmp4 = NULL ;
8976 PyObject *swig_obj[3] ;
8977
8978 (void)self;
8979 if (!SWIG_Python_UnpackTuple(args, "plline3", 3, 3, swig_obj)) SWIG_fail;
8980 {
8981 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
8982 if ( tmp1 == NULL )
8983 return NULL;
8984 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
8985 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
8986 }
8987 {
8988 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
8989 if ( tmp3 == NULL )
8990 return NULL;
8991 if ( PyArray_DIMS( tmp3 )[0] != Alen )
8992 {
8993 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
8994 return NULL;
8995 }
8996 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
8997 }
8998 {
8999 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
9000 if ( tmp4 == NULL )
9001 return NULL;
9002 if ( PyArray_DIMS( tmp4 )[0] != Alen )
9003 {
9004 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9005 return NULL;
9006 }
9007 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
9008 }
9009 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
9010 resultobj = SWIG_Py_Void();
9011 {
9012 Py_CLEAR( tmp1 );
9013 }
9014 {
9015 Py_CLEAR( tmp3 );
9016 }
9017 {
9018 Py_CLEAR( tmp4 );
9019 }
9020 return resultobj;
9021fail:
9022 {
9023 Py_CLEAR( tmp1 );
9024 }
9025 {
9026 Py_CLEAR( tmp3 );
9027 }
9028 {
9029 Py_CLEAR( tmp4 );
9030 }
9031 return NULL;
9032}
9033
9034
9035SWIGINTERN PyObject *_wrap_pllsty(PyObject *self, PyObject *args) {
9036 PyObject *resultobj = 0;
9037 PLINT arg1 ;
9038 int val1 ;
9039 int ecode1 = 0 ;
9040 PyObject *swig_obj[1] ;
9041
9042 (void)self;
9043 if (!args) SWIG_fail;
9044 swig_obj[0] = args;
9045 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
9046 if (!SWIG_IsOK(ecode1)) {
9047 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
9048 }
9049 arg1 = (PLINT)(val1);
9050 pllsty(arg1);
9051 resultobj = SWIG_Py_Void();
9052 return resultobj;
9053fail:
9054 return NULL;
9055}
9056
9057
9058SWIGINTERN PyObject *_wrap_plmesh(PyObject *self, PyObject *args) {
9059 PyObject *resultobj = 0;
9060 PLFLT *arg1 = (PLFLT *) 0 ;
9061 PLFLT *arg2 = (PLFLT *) 0 ;
9062 PLFLT **arg3 = (PLFLT **) 0 ;
9063 PLINT arg4 ;
9064 PLINT arg5 ;
9065 PLINT arg6 ;
9066 PyArrayObject *tmp1 = NULL ;
9067 PyArrayObject *tmp2 = NULL ;
9068 PyArrayObject *tmp3 = NULL ;
9069 int val6 ;
9070 int ecode6 = 0 ;
9071 PyObject *swig_obj[4] ;
9072
9073 (void)self;
9074 if (!SWIG_Python_UnpackTuple(args, "plmesh", 4, 4, swig_obj)) SWIG_fail;
9075 {
9076 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9077 if ( tmp1 == NULL )
9078 return NULL;
9079 Xlen = PyArray_DIMS( tmp1 )[0];
9080 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9081 }
9082 {
9083 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9084 if ( tmp2 == NULL )
9085 return NULL;
9086 Ylen = PyArray_DIMS( tmp2 )[0];
9087 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9088 }
9089 {
9090 int i, size;
9091 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9092 if ( tmp3 == NULL )
9093 return NULL;
9094 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9095 {
9096 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9097 return NULL;
9098 }
9099 arg4 = PyArray_DIMS( tmp3 )[0];
9100 arg5 = PyArray_DIMS( tmp3 )[1];
9101 size = arg5;
9102 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9103 for ( i = 0; i < arg4; i++ )
9104 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9105 }
9106 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9107 if (!SWIG_IsOK(ecode6)) {
9108 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
9109 }
9110 arg6 = (PLINT)(val6);
9111 plmesh((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6);
9112 resultobj = SWIG_Py_Void();
9113 {
9114 Py_CLEAR( tmp1 );
9115 }
9116 {
9117 Py_CLEAR( tmp2 );
9118 }
9119 {
9120 Py_CLEAR( tmp3 );
9121 free( arg3 );
9122 }
9123 return resultobj;
9124fail:
9125 {
9126 Py_CLEAR( tmp1 );
9127 }
9128 {
9129 Py_CLEAR( tmp2 );
9130 }
9131 {
9132 Py_CLEAR( tmp3 );
9133 free( arg3 );
9134 }
9135 return NULL;
9136}
9137
9138
9139SWIGINTERN PyObject *_wrap_plmeshc(PyObject *self, PyObject *args) {
9140 PyObject *resultobj = 0;
9141 PLFLT *arg1 = (PLFLT *) 0 ;
9142 PLFLT *arg2 = (PLFLT *) 0 ;
9143 PLFLT **arg3 = (PLFLT **) 0 ;
9144 PLINT arg4 ;
9145 PLINT arg5 ;
9146 PLINT arg6 ;
9147 PLFLT *arg7 = (PLFLT *) 0 ;
9148 PLINT arg8 ;
9149 PyArrayObject *tmp1 = NULL ;
9150 PyArrayObject *tmp2 = NULL ;
9151 PyArrayObject *tmp3 = NULL ;
9152 int val6 ;
9153 int ecode6 = 0 ;
9154 PyArrayObject *tmp7 = NULL ;
9155 PyObject *swig_obj[5] ;
9156
9157 (void)self;
9158 if (!SWIG_Python_UnpackTuple(args, "plmeshc", 5, 5, swig_obj)) SWIG_fail;
9159 {
9160 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9161 if ( tmp1 == NULL )
9162 return NULL;
9163 Xlen = PyArray_DIMS( tmp1 )[0];
9164 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9165 }
9166 {
9167 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9168 if ( tmp2 == NULL )
9169 return NULL;
9170 Ylen = PyArray_DIMS( tmp2 )[0];
9171 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9172 }
9173 {
9174 int i, size;
9175 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9176 if ( tmp3 == NULL )
9177 return NULL;
9178 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9179 {
9180 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9181 return NULL;
9182 }
9183 arg4 = PyArray_DIMS( tmp3 )[0];
9184 arg5 = PyArray_DIMS( tmp3 )[1];
9185 size = arg5;
9186 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9187 for ( i = 0; i < arg4; i++ )
9188 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9189 }
9190 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9191 if (!SWIG_IsOK(ecode6)) {
9192 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9193 }
9194 arg6 = (PLINT)(val6);
9195 {
9196 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9197 if ( tmp7 == NULL )
9198 return NULL;
9199 arg8 = PyArray_DIMS( tmp7 )[0];
9200 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9201 }
9202 plmeshc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9203 resultobj = SWIG_Py_Void();
9204 {
9205 Py_CLEAR( tmp1 );
9206 }
9207 {
9208 Py_CLEAR( tmp2 );
9209 }
9210 {
9211 Py_CLEAR( tmp3 );
9212 free( arg3 );
9213 }
9214 {
9215 Py_CLEAR( tmp7 );
9216 }
9217 return resultobj;
9218fail:
9219 {
9220 Py_CLEAR( tmp1 );
9221 }
9222 {
9223 Py_CLEAR( tmp2 );
9224 }
9225 {
9226 Py_CLEAR( tmp3 );
9227 free( arg3 );
9228 }
9229 {
9230 Py_CLEAR( tmp7 );
9231 }
9232 return NULL;
9233}
9234
9235
9236SWIGINTERN PyObject *_wrap_plmkstrm(PyObject *self, PyObject *args) {
9237 PyObject *resultobj = 0;
9238 PLINT *arg1 = (PLINT *) 0 ;
9239 PLINT temp1 ;
9240 int res1 = SWIG_TMPOBJ ;
9241
9242 arg1 = &temp1;
9243 (void)self;
9244 if (!SWIG_Python_UnpackTuple(args, "plmkstrm", 0, 0, 0)) SWIG_fail;
9245 plmkstrm(arg1);
9246 resultobj = SWIG_Py_Void();
9247 if (SWIG_IsTmpObj(res1)) {
9248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
9249 } else {
9250 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
9251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
9252 }
9253 return resultobj;
9254fail:
9255 return NULL;
9256}
9257
9258
9259SWIGINTERN PyObject *_wrap_plmtex(PyObject *self, PyObject *args) {
9260 PyObject *resultobj = 0;
9261 char *arg1 = (char *) 0 ;
9262 PLFLT arg2 ;
9263 PLFLT arg3 ;
9264 PLFLT arg4 ;
9265 char *arg5 = (char *) 0 ;
9266 int res1 ;
9267 char *buf1 = 0 ;
9268 int alloc1 = 0 ;
9269 double val2 ;
9270 int ecode2 = 0 ;
9271 double val3 ;
9272 int ecode3 = 0 ;
9273 double val4 ;
9274 int ecode4 = 0 ;
9275 int res5 ;
9276 char *buf5 = 0 ;
9277 int alloc5 = 0 ;
9278 PyObject *swig_obj[5] ;
9279
9280 (void)self;
9281 if (!SWIG_Python_UnpackTuple(args, "plmtex", 5, 5, swig_obj)) SWIG_fail;
9282 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9283 if (!SWIG_IsOK(res1)) {
9284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
9285 }
9286 arg1 = (char *)(buf1);
9287 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9288 if (!SWIG_IsOK(ecode2)) {
9289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
9290 }
9291 arg2 = (PLFLT)(val2);
9292 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9293 if (!SWIG_IsOK(ecode3)) {
9294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
9295 }
9296 arg3 = (PLFLT)(val3);
9297 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9298 if (!SWIG_IsOK(ecode4)) {
9299 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
9300 }
9301 arg4 = (PLFLT)(val4);
9302 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9303 if (!SWIG_IsOK(res5)) {
9304 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
9305 }
9306 arg5 = (char *)(buf5);
9307 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9308 resultobj = SWIG_Py_Void();
9309 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9310 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9311 return resultobj;
9312fail:
9313 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9314 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9315 return NULL;
9316}
9317
9318
9319SWIGINTERN PyObject *_wrap_plmtex3(PyObject *self, PyObject *args) {
9320 PyObject *resultobj = 0;
9321 char *arg1 = (char *) 0 ;
9322 PLFLT arg2 ;
9323 PLFLT arg3 ;
9324 PLFLT arg4 ;
9325 char *arg5 = (char *) 0 ;
9326 int res1 ;
9327 char *buf1 = 0 ;
9328 int alloc1 = 0 ;
9329 double val2 ;
9330 int ecode2 = 0 ;
9331 double val3 ;
9332 int ecode3 = 0 ;
9333 double val4 ;
9334 int ecode4 = 0 ;
9335 int res5 ;
9336 char *buf5 = 0 ;
9337 int alloc5 = 0 ;
9338 PyObject *swig_obj[5] ;
9339
9340 (void)self;
9341 if (!SWIG_Python_UnpackTuple(args, "plmtex3", 5, 5, swig_obj)) SWIG_fail;
9342 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
9343 if (!SWIG_IsOK(res1)) {
9344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
9345 }
9346 arg1 = (char *)(buf1);
9347 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9348 if (!SWIG_IsOK(ecode2)) {
9349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
9350 }
9351 arg2 = (PLFLT)(val2);
9352 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
9353 if (!SWIG_IsOK(ecode3)) {
9354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
9355 }
9356 arg3 = (PLFLT)(val3);
9357 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
9358 if (!SWIG_IsOK(ecode4)) {
9359 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
9360 }
9361 arg4 = (PLFLT)(val4);
9362 res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
9363 if (!SWIG_IsOK(res5)) {
9364 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
9365 }
9366 arg5 = (char *)(buf5);
9367 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
9368 resultobj = SWIG_Py_Void();
9369 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9370 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9371 return resultobj;
9372fail:
9373 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
9374 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
9375 return NULL;
9376}
9377
9378
9379SWIGINTERN PyObject *_wrap_plot3d(PyObject *self, PyObject *args) {
9380 PyObject *resultobj = 0;
9381 PLFLT *arg1 = (PLFLT *) 0 ;
9382 PLFLT *arg2 = (PLFLT *) 0 ;
9383 PLFLT **arg3 = (PLFLT **) 0 ;
9384 PLINT arg4 ;
9385 PLINT arg5 ;
9386 PLINT arg6 ;
9387 PLBOOL arg7 ;
9388 PyArrayObject *tmp1 = NULL ;
9389 PyArrayObject *tmp2 = NULL ;
9390 PyArrayObject *tmp3 = NULL ;
9391 int val6 ;
9392 int ecode6 = 0 ;
9393 int val7 ;
9394 int ecode7 = 0 ;
9395 PyObject *swig_obj[5] ;
9396
9397 (void)self;
9398 if (!SWIG_Python_UnpackTuple(args, "plot3d", 5, 5, swig_obj)) SWIG_fail;
9399 {
9400 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9401 if ( tmp1 == NULL )
9402 return NULL;
9403 Xlen = PyArray_DIMS( tmp1 )[0];
9404 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9405 }
9406 {
9407 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9408 if ( tmp2 == NULL )
9409 return NULL;
9410 Ylen = PyArray_DIMS( tmp2 )[0];
9411 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9412 }
9413 {
9414 int i, size;
9415 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9416 if ( tmp3 == NULL )
9417 return NULL;
9418 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9419 {
9420 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9421 return NULL;
9422 }
9423 arg4 = PyArray_DIMS( tmp3 )[0];
9424 arg5 = PyArray_DIMS( tmp3 )[1];
9425 size = arg5;
9426 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9427 for ( i = 0; i < arg4; i++ )
9428 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9429 }
9430 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9431 if (!SWIG_IsOK(ecode6)) {
9432 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9433 }
9434 arg6 = (PLINT)(val6);
9435 ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
9436 if (!SWIG_IsOK(ecode7)) {
9437 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9438 }
9439 arg7 = (PLBOOL)(val7);
9440 plot3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,arg7);
9441 resultobj = SWIG_Py_Void();
9442 {
9443 Py_CLEAR( tmp1 );
9444 }
9445 {
9446 Py_CLEAR( tmp2 );
9447 }
9448 {
9449 Py_CLEAR( tmp3 );
9450 free( arg3 );
9451 }
9452 return resultobj;
9453fail:
9454 {
9455 Py_CLEAR( tmp1 );
9456 }
9457 {
9458 Py_CLEAR( tmp2 );
9459 }
9460 {
9461 Py_CLEAR( tmp3 );
9462 free( arg3 );
9463 }
9464 return NULL;
9465}
9466
9467
9468SWIGINTERN PyObject *_wrap_plot3dc(PyObject *self, PyObject *args) {
9469 PyObject *resultobj = 0;
9470 PLFLT *arg1 = (PLFLT *) 0 ;
9471 PLFLT *arg2 = (PLFLT *) 0 ;
9472 PLFLT **arg3 = (PLFLT **) 0 ;
9473 PLINT arg4 ;
9474 PLINT arg5 ;
9475 PLINT arg6 ;
9476 PLFLT *arg7 = (PLFLT *) 0 ;
9477 PLINT arg8 ;
9478 PyArrayObject *tmp1 = NULL ;
9479 PyArrayObject *tmp2 = NULL ;
9480 PyArrayObject *tmp3 = NULL ;
9481 int val6 ;
9482 int ecode6 = 0 ;
9483 PyArrayObject *tmp7 = NULL ;
9484 PyObject *swig_obj[5] ;
9485
9486 (void)self;
9487 if (!SWIG_Python_UnpackTuple(args, "plot3dc", 5, 5, swig_obj)) SWIG_fail;
9488 {
9489 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9490 if ( tmp1 == NULL )
9491 return NULL;
9492 Xlen = PyArray_DIMS( tmp1 )[0];
9493 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9494 }
9495 {
9496 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9497 if ( tmp2 == NULL )
9498 return NULL;
9499 Ylen = PyArray_DIMS( tmp2 )[0];
9500 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9501 }
9502 {
9503 int i, size;
9504 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9505 if ( tmp3 == NULL )
9506 return NULL;
9507 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9508 {
9509 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9510 return NULL;
9511 }
9512 arg4 = PyArray_DIMS( tmp3 )[0];
9513 arg5 = PyArray_DIMS( tmp3 )[1];
9514 size = arg5;
9515 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9516 for ( i = 0; i < arg4; i++ )
9517 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9518 }
9519 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9520 if (!SWIG_IsOK(ecode6)) {
9521 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9522 }
9523 arg6 = (PLINT)(val6);
9524 {
9525 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9526 if ( tmp7 == NULL )
9527 return NULL;
9528 arg8 = PyArray_DIMS( tmp7 )[0];
9529 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9530 }
9531 plot3dc((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9532 resultobj = SWIG_Py_Void();
9533 {
9534 Py_CLEAR( tmp1 );
9535 }
9536 {
9537 Py_CLEAR( tmp2 );
9538 }
9539 {
9540 Py_CLEAR( tmp3 );
9541 free( arg3 );
9542 }
9543 {
9544 Py_CLEAR( tmp7 );
9545 }
9546 return resultobj;
9547fail:
9548 {
9549 Py_CLEAR( tmp1 );
9550 }
9551 {
9552 Py_CLEAR( tmp2 );
9553 }
9554 {
9555 Py_CLEAR( tmp3 );
9556 free( arg3 );
9557 }
9558 {
9559 Py_CLEAR( tmp7 );
9560 }
9561 return NULL;
9562}
9563
9564
9565SWIGINTERN PyObject *_wrap_plot3dcl(PyObject *self, PyObject *args) {
9566 PyObject *resultobj = 0;
9567 PLFLT *arg1 = (PLFLT *) 0 ;
9568 PLFLT *arg2 = (PLFLT *) 0 ;
9569 PLFLT **arg3 = (PLFLT **) 0 ;
9570 PLINT arg4 ;
9571 PLINT arg5 ;
9572 PLINT arg6 ;
9573 PLFLT *arg7 = (PLFLT *) 0 ;
9574 PLINT arg8 ;
9575 PLINT arg9 ;
9576 PLINT arg10 ;
9577 PLINT *arg11 = (PLINT *) 0 ;
9578 PLINT *arg12 = (PLINT *) 0 ;
9579 PyArrayObject *tmp1 = NULL ;
9580 PyArrayObject *tmp2 = NULL ;
9581 PyArrayObject *tmp3 = NULL ;
9582 int val6 ;
9583 int ecode6 = 0 ;
9584 PyArrayObject *tmp7 = NULL ;
9585 int val9 ;
9586 int ecode9 = 0 ;
9587 PyArrayObject *tmp10 = NULL ;
9588 PyArrayObject *tmp12 = NULL ;
9589 PyObject *swig_obj[8] ;
9590
9591 (void)self;
9592 if (!SWIG_Python_UnpackTuple(args, "plot3dcl", 8, 8, swig_obj)) SWIG_fail;
9593 {
9594 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9595 if ( tmp1 == NULL )
9596 return NULL;
9597 Xlen = PyArray_DIMS( tmp1 )[0];
9598 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9599 }
9600 {
9601 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9602 if ( tmp2 == NULL )
9603 return NULL;
9604 Ylen = PyArray_DIMS( tmp2 )[0];
9605 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9606 }
9607 {
9608 int i, size;
9609 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9610 if ( tmp3 == NULL )
9611 return NULL;
9612 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9613 {
9614 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9615 return NULL;
9616 }
9617 arg4 = PyArray_DIMS( tmp3 )[0];
9618 arg5 = PyArray_DIMS( tmp3 )[1];
9619 size = arg5;
9620 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9621 for ( i = 0; i < arg4; i++ )
9622 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9623 }
9624 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9625 if (!SWIG_IsOK(ecode6)) {
9626 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
9627 }
9628 arg6 = (PLINT)(val6);
9629 {
9630 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9631 if ( tmp7 == NULL )
9632 return NULL;
9633 arg8 = PyArray_DIMS( tmp7 )[0];
9634 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9635 }
9636 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9637 if (!SWIG_IsOK(ecode9)) {
9638 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
9639 }
9640 arg9 = (PLINT)(val9);
9641 {
9642 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9643 if ( tmp10 == NULL )
9644 return NULL;
9645 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9646 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9647 }
9648 {
9649 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9650 if ( tmp12 == NULL )
9651 return NULL;
9652 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9653 {
9654 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9655 return NULL;
9656 }
9657 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9658 }
9659 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);
9660 resultobj = SWIG_Py_Void();
9661 {
9662 Py_CLEAR( tmp1 );
9663 }
9664 {
9665 Py_CLEAR( tmp2 );
9666 }
9667 {
9668 Py_CLEAR( tmp3 );
9669 free( arg3 );
9670 }
9671 {
9672 Py_CLEAR( tmp7 );
9673 }
9674 {
9675 Py_CLEAR( tmp10 );
9676 }
9677 {
9678 Py_CLEAR( tmp12 );
9679 }
9680 return resultobj;
9681fail:
9682 {
9683 Py_CLEAR( tmp1 );
9684 }
9685 {
9686 Py_CLEAR( tmp2 );
9687 }
9688 {
9689 Py_CLEAR( tmp3 );
9690 free( arg3 );
9691 }
9692 {
9693 Py_CLEAR( tmp7 );
9694 }
9695 {
9696 Py_CLEAR( tmp10 );
9697 }
9698 {
9699 Py_CLEAR( tmp12 );
9700 }
9701 return NULL;
9702}
9703
9704
9705SWIGINTERN PyObject *_wrap_plsurf3d(PyObject *self, PyObject *args) {
9706 PyObject *resultobj = 0;
9707 PLFLT *arg1 = (PLFLT *) 0 ;
9708 PLFLT *arg2 = (PLFLT *) 0 ;
9709 PLFLT **arg3 = (PLFLT **) 0 ;
9710 PLINT arg4 ;
9711 PLINT arg5 ;
9712 PLINT arg6 ;
9713 PLFLT *arg7 = (PLFLT *) 0 ;
9714 PLINT arg8 ;
9715 PyArrayObject *tmp1 = NULL ;
9716 PyArrayObject *tmp2 = NULL ;
9717 PyArrayObject *tmp3 = NULL ;
9718 int val6 ;
9719 int ecode6 = 0 ;
9720 PyArrayObject *tmp7 = NULL ;
9721 PyObject *swig_obj[5] ;
9722
9723 (void)self;
9724 if (!SWIG_Python_UnpackTuple(args, "plsurf3d", 5, 5, swig_obj)) SWIG_fail;
9725 {
9726 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9727 if ( tmp1 == NULL )
9728 return NULL;
9729 Xlen = PyArray_DIMS( tmp1 )[0];
9730 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9731 }
9732 {
9733 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9734 if ( tmp2 == NULL )
9735 return NULL;
9736 Ylen = PyArray_DIMS( tmp2 )[0];
9737 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9738 }
9739 {
9740 int i, size;
9741 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9742 if ( tmp3 == NULL )
9743 return NULL;
9744 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9745 {
9746 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9747 return NULL;
9748 }
9749 arg4 = PyArray_DIMS( tmp3 )[0];
9750 arg5 = PyArray_DIMS( tmp3 )[1];
9751 size = arg5;
9752 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9753 for ( i = 0; i < arg4; i++ )
9754 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9755 }
9756 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9757 if (!SWIG_IsOK(ecode6)) {
9758 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9759 }
9760 arg6 = (PLINT)(val6);
9761 {
9762 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9763 if ( tmp7 == NULL )
9764 return NULL;
9765 arg8 = PyArray_DIMS( tmp7 )[0];
9766 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9767 }
9768 plsurf3d((double const *)arg1,(double const *)arg2,(double const **)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9769 resultobj = SWIG_Py_Void();
9770 {
9771 Py_CLEAR( tmp1 );
9772 }
9773 {
9774 Py_CLEAR( tmp2 );
9775 }
9776 {
9777 Py_CLEAR( tmp3 );
9778 free( arg3 );
9779 }
9780 {
9781 Py_CLEAR( tmp7 );
9782 }
9783 return resultobj;
9784fail:
9785 {
9786 Py_CLEAR( tmp1 );
9787 }
9788 {
9789 Py_CLEAR( tmp2 );
9790 }
9791 {
9792 Py_CLEAR( tmp3 );
9793 free( arg3 );
9794 }
9795 {
9796 Py_CLEAR( tmp7 );
9797 }
9798 return NULL;
9799}
9800
9801
9802SWIGINTERN PyObject *_wrap_plsurf3dl(PyObject *self, PyObject *args) {
9803 PyObject *resultobj = 0;
9804 PLFLT *arg1 = (PLFLT *) 0 ;
9805 PLFLT *arg2 = (PLFLT *) 0 ;
9806 PLFLT **arg3 = (PLFLT **) 0 ;
9807 PLINT arg4 ;
9808 PLINT arg5 ;
9809 PLINT arg6 ;
9810 PLFLT *arg7 = (PLFLT *) 0 ;
9811 PLINT arg8 ;
9812 PLINT arg9 ;
9813 PLINT arg10 ;
9814 PLINT *arg11 = (PLINT *) 0 ;
9815 PLINT *arg12 = (PLINT *) 0 ;
9816 PyArrayObject *tmp1 = NULL ;
9817 PyArrayObject *tmp2 = NULL ;
9818 PyArrayObject *tmp3 = NULL ;
9819 int val6 ;
9820 int ecode6 = 0 ;
9821 PyArrayObject *tmp7 = NULL ;
9822 int val9 ;
9823 int ecode9 = 0 ;
9824 PyArrayObject *tmp10 = NULL ;
9825 PyArrayObject *tmp12 = NULL ;
9826 PyObject *swig_obj[8] ;
9827
9828 (void)self;
9829 if (!SWIG_Python_UnpackTuple(args, "plsurf3dl", 8, 8, swig_obj)) SWIG_fail;
9830 {
9831 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
9832 if ( tmp1 == NULL )
9833 return NULL;
9834 Xlen = PyArray_DIMS( tmp1 )[0];
9835 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
9836 }
9837 {
9838 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
9839 if ( tmp2 == NULL )
9840 return NULL;
9841 Ylen = PyArray_DIMS( tmp2 )[0];
9842 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
9843 }
9844 {
9845 int i, size;
9846 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 2, 2 );
9847 if ( tmp3 == NULL )
9848 return NULL;
9849 if ( Xlen != PyArray_DIMS( tmp3 )[0] || Ylen != PyArray_DIMS( tmp3 )[1] )
9850 {
9851 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
9852 return NULL;
9853 }
9854 arg4 = PyArray_DIMS( tmp3 )[0];
9855 arg5 = PyArray_DIMS( tmp3 )[1];
9856 size = arg5;
9857 arg3 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg4 );
9858 for ( i = 0; i < arg4; i++ )
9859 arg3[i] = ( (PLFLT *) PyArray_DATA( tmp3 ) + i * size );
9860 }
9861 ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
9862 if (!SWIG_IsOK(ecode6)) {
9863 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
9864 }
9865 arg6 = (PLINT)(val6);
9866 {
9867 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
9868 if ( tmp7 == NULL )
9869 return NULL;
9870 arg8 = PyArray_DIMS( tmp7 )[0];
9871 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
9872 }
9873 ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
9874 if (!SWIG_IsOK(ecode9)) {
9875 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
9876 }
9877 arg9 = (PLINT)(val9);
9878 {
9879 tmp10 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
9880 if ( tmp10 == NULL )
9881 return NULL;
9882 arg10 = Alen = PyArray_DIMS( tmp10 )[0];
9883 arg11 = (PLINT *) PyArray_DATA( tmp10 );
9884 }
9885 {
9886 tmp12 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
9887 if ( tmp12 == NULL )
9888 return NULL;
9889 if ( PyArray_DIMS( tmp12 )[0] != Alen )
9890 {
9891 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
9892 return NULL;
9893 }
9894 arg12 = (PLINT *) PyArray_DATA( tmp12 );
9895 }
9896 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);
9897 resultobj = SWIG_Py_Void();
9898 {
9899 Py_CLEAR( tmp1 );
9900 }
9901 {
9902 Py_CLEAR( tmp2 );
9903 }
9904 {
9905 Py_CLEAR( tmp3 );
9906 free( arg3 );
9907 }
9908 {
9909 Py_CLEAR( tmp7 );
9910 }
9911 {
9912 Py_CLEAR( tmp10 );
9913 }
9914 {
9915 Py_CLEAR( tmp12 );
9916 }
9917 return resultobj;
9918fail:
9919 {
9920 Py_CLEAR( tmp1 );
9921 }
9922 {
9923 Py_CLEAR( tmp2 );
9924 }
9925 {
9926 Py_CLEAR( tmp3 );
9927 free( arg3 );
9928 }
9929 {
9930 Py_CLEAR( tmp7 );
9931 }
9932 {
9933 Py_CLEAR( tmp10 );
9934 }
9935 {
9936 Py_CLEAR( tmp12 );
9937 }
9938 return NULL;
9939}
9940
9941
9942SWIGINTERN PyObject *_wrap_plparseopts(PyObject *self, PyObject *args) {
9943 PyObject *resultobj = 0;
9944 int *arg1 = (int *) 0 ;
9945 char **arg2 = (char **) 0 ;
9946 PLINT arg3 ;
9947 int tmp1 ;
9948 int val3 ;
9949 int ecode3 = 0 ;
9950 PyObject *swig_obj[2] ;
9951 PLINT result;
9952
9953 (void)self;
9954 if (!SWIG_Python_UnpackTuple(args, "plparseopts", 2, 2, swig_obj)) SWIG_fail;
9955 {
9956 int i;
9957 PyObject *unicode_string;
9958
9959 if ( !PyList_Check( swig_obj[0] ) )
9960 {
9961 PyErr_SetString( PyExc_ValueError, "Expecting a list" );
9962 return NULL;
9963 }
9964 tmp1 = PyList_Size( swig_obj[0] );
9965 arg1 = &tmp1;
9966 arg2 = (char **) malloc( (size_t) ( tmp1 + 1 ) * sizeof ( char * ) );
9967 for ( i = 0; i < tmp1; i++ )
9968 {
9969 PyObject *s = PyList_GetItem( swig_obj[0], i );
9970 if ( PyString_Check( s ) )
9971 {
9972 arg2[i] = PyString_AsString( s );
9973 }
9974 else if ( PyUnicode_Check( s ) )
9975 {
9976 // unicode_string is never freed? memory leak here?
9977 unicode_string = PyUnicode_AsEncodedString( s, "utf-8", "Error ~" );
9978 arg2[i] = PyBytes_AS_STRING( unicode_string );
9979 }
9980 else
9981 {
9982 free( arg2 );
9983 PyErr_SetString( PyExc_ValueError, "List items must be strings" );
9984 return NULL;
9985 }
9986 }
9987 arg2[i] = 0;
9988 }
9989 ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
9990 if (!SWIG_IsOK(ecode3)) {
9991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
9992 }
9993 arg3 = (PLINT)(val3);
9994 result = (PLINT)plparseopts(arg1,arg2,arg3);
9995 resultobj = SWIG_From_int((int)(result));
9996 {
9997 if ( arg2 )
9998 free( arg2 );
9999 }
10000 return resultobj;
10001fail:
10002 {
10003 if ( arg2 )
10004 free( arg2 );
10005 }
10006 return NULL;
10007}
10008
10009
10010SWIGINTERN PyObject *_wrap_plpat(PyObject *self, PyObject *args) {
10011 PyObject *resultobj = 0;
10012 PLINT arg1 ;
10013 PLINT *arg2 = (PLINT *) 0 ;
10014 PLINT *arg3 = (PLINT *) 0 ;
10015 PyArrayObject *tmp1 = NULL ;
10016 PyArrayObject *tmp3 = NULL ;
10017 PyObject *swig_obj[2] ;
10018
10019 (void)self;
10020 if (!SWIG_Python_UnpackTuple(args, "plpat", 2, 2, swig_obj)) SWIG_fail;
10021 {
10022 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10023 if ( tmp1 == NULL )
10024 return NULL;
10025 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10026 arg2 = (PLINT *) PyArray_DATA( tmp1 );
10027 }
10028 {
10029 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10030 if ( tmp3 == NULL )
10031 return NULL;
10032 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10033 {
10034 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10035 return NULL;
10036 }
10037 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10038 }
10039 plpat(arg1,(int const *)arg2,(int const *)arg3);
10040 resultobj = SWIG_Py_Void();
10041 {
10042 Py_CLEAR( tmp1 );
10043 }
10044 {
10045 Py_CLEAR( tmp3 );
10046 }
10047 return resultobj;
10048fail:
10049 {
10050 Py_CLEAR( tmp1 );
10051 }
10052 {
10053 Py_CLEAR( tmp3 );
10054 }
10055 return NULL;
10056}
10057
10058
10059SWIGINTERN PyObject *_wrap_plpath(PyObject *self, PyObject *args) {
10060 PyObject *resultobj = 0;
10061 PLINT arg1 ;
10062 PLFLT arg2 ;
10063 PLFLT arg3 ;
10064 PLFLT arg4 ;
10065 PLFLT arg5 ;
10066 int val1 ;
10067 int ecode1 = 0 ;
10068 double val2 ;
10069 int ecode2 = 0 ;
10070 double val3 ;
10071 int ecode3 = 0 ;
10072 double val4 ;
10073 int ecode4 = 0 ;
10074 double val5 ;
10075 int ecode5 = 0 ;
10076 PyObject *swig_obj[5] ;
10077
10078 (void)self;
10079 if (!SWIG_Python_UnpackTuple(args, "plpath", 5, 5, swig_obj)) SWIG_fail;
10080 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10081 if (!SWIG_IsOK(ecode1)) {
10082 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
10083 }
10084 arg1 = (PLINT)(val1);
10085 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10086 if (!SWIG_IsOK(ecode2)) {
10087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
10088 }
10089 arg2 = (PLFLT)(val2);
10090 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10091 if (!SWIG_IsOK(ecode3)) {
10092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
10093 }
10094 arg3 = (PLFLT)(val3);
10095 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10096 if (!SWIG_IsOK(ecode4)) {
10097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
10098 }
10099 arg4 = (PLFLT)(val4);
10100 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10101 if (!SWIG_IsOK(ecode5)) {
10102 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
10103 }
10104 arg5 = (PLFLT)(val5);
10105 plpath(arg1,arg2,arg3,arg4,arg5);
10106 resultobj = SWIG_Py_Void();
10107 return resultobj;
10108fail:
10109 return NULL;
10110}
10111
10112
10113SWIGINTERN PyObject *_wrap_plpoin(PyObject *self, PyObject *args) {
10114 PyObject *resultobj = 0;
10115 PLINT arg1 ;
10116 PLFLT *arg2 = (PLFLT *) 0 ;
10117 PLFLT *arg3 = (PLFLT *) 0 ;
10118 PLINT arg4 ;
10119 PyArrayObject *tmp1 = NULL ;
10120 PyArrayObject *tmp3 = NULL ;
10121 int val4 ;
10122 int ecode4 = 0 ;
10123 PyObject *swig_obj[3] ;
10124
10125 (void)self;
10126 if (!SWIG_Python_UnpackTuple(args, "plpoin", 3, 3, swig_obj)) SWIG_fail;
10127 {
10128 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10129 if ( tmp1 == NULL )
10130 return NULL;
10131 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10132 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10133 }
10134 {
10135 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10136 if ( tmp3 == NULL )
10137 return NULL;
10138 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10139 {
10140 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10141 return NULL;
10142 }
10143 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10144 }
10145 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
10146 if (!SWIG_IsOK(ecode4)) {
10147 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
10148 }
10149 arg4 = (PLINT)(val4);
10150 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
10151 resultobj = SWIG_Py_Void();
10152 {
10153 Py_CLEAR( tmp1 );
10154 }
10155 {
10156 Py_CLEAR( tmp3 );
10157 }
10158 return resultobj;
10159fail:
10160 {
10161 Py_CLEAR( tmp1 );
10162 }
10163 {
10164 Py_CLEAR( tmp3 );
10165 }
10166 return NULL;
10167}
10168
10169
10170SWIGINTERN PyObject *_wrap_plpoin3(PyObject *self, PyObject *args) {
10171 PyObject *resultobj = 0;
10172 PLINT arg1 ;
10173 PLFLT *arg2 = (PLFLT *) 0 ;
10174 PLFLT *arg3 = (PLFLT *) 0 ;
10175 PLFLT *arg4 = (PLFLT *) 0 ;
10176 PLINT arg5 ;
10177 PyArrayObject *tmp1 = NULL ;
10178 PyArrayObject *tmp3 = NULL ;
10179 PyArrayObject *tmp4 = NULL ;
10180 int val5 ;
10181 int ecode5 = 0 ;
10182 PyObject *swig_obj[4] ;
10183
10184 (void)self;
10185 if (!SWIG_Python_UnpackTuple(args, "plpoin3", 4, 4, swig_obj)) SWIG_fail;
10186 {
10187 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10188 if ( tmp1 == NULL )
10189 return NULL;
10190 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10191 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10192 }
10193 {
10194 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10195 if ( tmp3 == NULL )
10196 return NULL;
10197 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10198 {
10199 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10200 return NULL;
10201 }
10202 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10203 }
10204 {
10205 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10206 if ( tmp4 == NULL )
10207 return NULL;
10208 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10209 {
10210 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10211 return NULL;
10212 }
10213 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10214 }
10215 ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
10216 if (!SWIG_IsOK(ecode5)) {
10217 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
10218 }
10219 arg5 = (PLINT)(val5);
10220 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
10221 resultobj = SWIG_Py_Void();
10222 {
10223 Py_CLEAR( tmp1 );
10224 }
10225 {
10226 Py_CLEAR( tmp3 );
10227 }
10228 {
10229 Py_CLEAR( tmp4 );
10230 }
10231 return resultobj;
10232fail:
10233 {
10234 Py_CLEAR( tmp1 );
10235 }
10236 {
10237 Py_CLEAR( tmp3 );
10238 }
10239 {
10240 Py_CLEAR( tmp4 );
10241 }
10242 return NULL;
10243}
10244
10245
10246SWIGINTERN PyObject *_wrap_plpoly3(PyObject *self, PyObject *args) {
10247 PyObject *resultobj = 0;
10248 PLINT arg1 ;
10249 PLFLT *arg2 = (PLFLT *) 0 ;
10250 PLFLT *arg3 = (PLFLT *) 0 ;
10251 PLFLT *arg4 = (PLFLT *) 0 ;
10252 PLBOOL *arg5 = (PLBOOL *) 0 ;
10253 PLBOOL arg6 ;
10254 PyArrayObject *tmp1 = NULL ;
10255 PyArrayObject *tmp3 = NULL ;
10256 PyArrayObject *tmp4 = NULL ;
10257 PyArrayObject *tmp5 = NULL ;
10258 int val6 ;
10259 int ecode6 = 0 ;
10260 PyObject *swig_obj[5] ;
10261
10262 (void)self;
10263 if (!SWIG_Python_UnpackTuple(args, "plpoly3", 5, 5, swig_obj)) SWIG_fail;
10264 {
10265 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
10266 if ( tmp1 == NULL )
10267 return NULL;
10268 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
10269 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
10270 }
10271 {
10272 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
10273 if ( tmp3 == NULL )
10274 return NULL;
10275 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10276 {
10277 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10278 return NULL;
10279 }
10280 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
10281 }
10282 {
10283 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
10284 if ( tmp4 == NULL )
10285 return NULL;
10286 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10287 {
10288 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10289 return NULL;
10290 }
10291 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10292 }
10293 {
10294 tmp5 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[3], NPY_PLINT, 1, 1 );
10295 if ( tmp5 == NULL )
10296 return NULL;
10297 if ( PyArray_DIMS( tmp5 )[0] < Alen - 1 )
10298 {
10299 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
10300 return NULL;
10301 }
10302 arg5 = (PLINT *) PyArray_DATA( tmp5 );
10303 }
10304 ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
10305 if (!SWIG_IsOK(ecode6)) {
10306 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
10307 }
10308 arg6 = (PLBOOL)(val6);
10309 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
10310 resultobj = SWIG_Py_Void();
10311 {
10312 Py_CLEAR( tmp1 );
10313 }
10314 {
10315 Py_CLEAR( tmp3 );
10316 }
10317 {
10318 Py_CLEAR( tmp4 );
10319 }
10320 {
10321 Py_CLEAR( tmp5 );
10322 }
10323 return resultobj;
10324fail:
10325 {
10326 Py_CLEAR( tmp1 );
10327 }
10328 {
10329 Py_CLEAR( tmp3 );
10330 }
10331 {
10332 Py_CLEAR( tmp4 );
10333 }
10334 {
10335 Py_CLEAR( tmp5 );
10336 }
10337 return NULL;
10338}
10339
10340
10341SWIGINTERN PyObject *_wrap_plprec(PyObject *self, PyObject *args) {
10342 PyObject *resultobj = 0;
10343 PLINT arg1 ;
10344 PLINT arg2 ;
10345 int val1 ;
10346 int ecode1 = 0 ;
10347 int val2 ;
10348 int ecode2 = 0 ;
10349 PyObject *swig_obj[2] ;
10350
10351 (void)self;
10352 if (!SWIG_Python_UnpackTuple(args, "plprec", 2, 2, swig_obj)) SWIG_fail;
10353 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10354 if (!SWIG_IsOK(ecode1)) {
10355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
10356 }
10357 arg1 = (PLINT)(val1);
10358 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10359 if (!SWIG_IsOK(ecode2)) {
10360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
10361 }
10362 arg2 = (PLINT)(val2);
10363 plprec(arg1,arg2);
10364 resultobj = SWIG_Py_Void();
10365 return resultobj;
10366fail:
10367 return NULL;
10368}
10369
10370
10371SWIGINTERN PyObject *_wrap_plpsty(PyObject *self, PyObject *args) {
10372 PyObject *resultobj = 0;
10373 PLINT arg1 ;
10374 int val1 ;
10375 int ecode1 = 0 ;
10376 PyObject *swig_obj[1] ;
10377
10378 (void)self;
10379 if (!args) SWIG_fail;
10380 swig_obj[0] = args;
10381 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10382 if (!SWIG_IsOK(ecode1)) {
10383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
10384 }
10385 arg1 = (PLINT)(val1);
10386 plpsty(arg1);
10387 resultobj = SWIG_Py_Void();
10388 return resultobj;
10389fail:
10390 return NULL;
10391}
10392
10393
10394SWIGINTERN PyObject *_wrap_plptex(PyObject *self, PyObject *args) {
10395 PyObject *resultobj = 0;
10396 PLFLT arg1 ;
10397 PLFLT arg2 ;
10398 PLFLT arg3 ;
10399 PLFLT arg4 ;
10400 PLFLT arg5 ;
10401 char *arg6 = (char *) 0 ;
10402 double val1 ;
10403 int ecode1 = 0 ;
10404 double val2 ;
10405 int ecode2 = 0 ;
10406 double val3 ;
10407 int ecode3 = 0 ;
10408 double val4 ;
10409 int ecode4 = 0 ;
10410 double val5 ;
10411 int ecode5 = 0 ;
10412 int res6 ;
10413 char *buf6 = 0 ;
10414 int alloc6 = 0 ;
10415 PyObject *swig_obj[6] ;
10416
10417 (void)self;
10418 if (!SWIG_Python_UnpackTuple(args, "plptex", 6, 6, swig_obj)) SWIG_fail;
10419 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10420 if (!SWIG_IsOK(ecode1)) {
10421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
10422 }
10423 arg1 = (PLFLT)(val1);
10424 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10425 if (!SWIG_IsOK(ecode2)) {
10426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
10427 }
10428 arg2 = (PLFLT)(val2);
10429 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10430 if (!SWIG_IsOK(ecode3)) {
10431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
10432 }
10433 arg3 = (PLFLT)(val3);
10434 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10435 if (!SWIG_IsOK(ecode4)) {
10436 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
10437 }
10438 arg4 = (PLFLT)(val4);
10439 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10440 if (!SWIG_IsOK(ecode5)) {
10441 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
10442 }
10443 arg5 = (PLFLT)(val5);
10444 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
10445 if (!SWIG_IsOK(res6)) {
10446 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
10447 }
10448 arg6 = (char *)(buf6);
10449 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
10450 resultobj = SWIG_Py_Void();
10451 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10452 return resultobj;
10453fail:
10454 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
10455 return NULL;
10456}
10457
10458
10459SWIGINTERN PyObject *_wrap_plptex3(PyObject *self, PyObject *args) {
10460 PyObject *resultobj = 0;
10461 PLFLT arg1 ;
10462 PLFLT arg2 ;
10463 PLFLT arg3 ;
10464 PLFLT arg4 ;
10465 PLFLT arg5 ;
10466 PLFLT arg6 ;
10467 PLFLT arg7 ;
10468 PLFLT arg8 ;
10469 PLFLT arg9 ;
10470 PLFLT arg10 ;
10471 char *arg11 = (char *) 0 ;
10472 double val1 ;
10473 int ecode1 = 0 ;
10474 double val2 ;
10475 int ecode2 = 0 ;
10476 double val3 ;
10477 int ecode3 = 0 ;
10478 double val4 ;
10479 int ecode4 = 0 ;
10480 double val5 ;
10481 int ecode5 = 0 ;
10482 double val6 ;
10483 int ecode6 = 0 ;
10484 double val7 ;
10485 int ecode7 = 0 ;
10486 double val8 ;
10487 int ecode8 = 0 ;
10488 double val9 ;
10489 int ecode9 = 0 ;
10490 double val10 ;
10491 int ecode10 = 0 ;
10492 int res11 ;
10493 char *buf11 = 0 ;
10494 int alloc11 = 0 ;
10495 PyObject *swig_obj[11] ;
10496
10497 (void)self;
10498 if (!SWIG_Python_UnpackTuple(args, "plptex3", 11, 11, swig_obj)) SWIG_fail;
10499 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10500 if (!SWIG_IsOK(ecode1)) {
10501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
10502 }
10503 arg1 = (PLFLT)(val1);
10504 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10505 if (!SWIG_IsOK(ecode2)) {
10506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
10507 }
10508 arg2 = (PLFLT)(val2);
10509 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10510 if (!SWIG_IsOK(ecode3)) {
10511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
10512 }
10513 arg3 = (PLFLT)(val3);
10514 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
10515 if (!SWIG_IsOK(ecode4)) {
10516 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
10517 }
10518 arg4 = (PLFLT)(val4);
10519 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
10520 if (!SWIG_IsOK(ecode5)) {
10521 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
10522 }
10523 arg5 = (PLFLT)(val5);
10524 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
10525 if (!SWIG_IsOK(ecode6)) {
10526 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
10527 }
10528 arg6 = (PLFLT)(val6);
10529 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
10530 if (!SWIG_IsOK(ecode7)) {
10531 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
10532 }
10533 arg7 = (PLFLT)(val7);
10534 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
10535 if (!SWIG_IsOK(ecode8)) {
10536 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
10537 }
10538 arg8 = (PLFLT)(val8);
10539 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
10540 if (!SWIG_IsOK(ecode9)) {
10541 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
10542 }
10543 arg9 = (PLFLT)(val9);
10544 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
10545 if (!SWIG_IsOK(ecode10)) {
10546 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
10547 }
10548 arg10 = (PLFLT)(val10);
10549 res11 = SWIG_AsCharPtrAndSize(swig_obj[10], &buf11, NULL, &alloc11);
10550 if (!SWIG_IsOK(res11)) {
10551 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
10552 }
10553 arg11 = (char *)(buf11);
10554 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
10555 resultobj = SWIG_Py_Void();
10556 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10557 return resultobj;
10558fail:
10559 if (alloc11 == SWIG_NEWOBJ) free((char*)buf11);
10560 return NULL;
10561}
10562
10563
10564SWIGINTERN PyObject *_wrap_plrandd(PyObject *self, PyObject *args) {
10565 PyObject *resultobj = 0;
10566 PLFLT result;
10567
10568 (void)self;
10569 if (!SWIG_Python_UnpackTuple(args, "plrandd", 0, 0, 0)) SWIG_fail;
10570 result = (PLFLT)plrandd();
10571 resultobj = SWIG_From_double((double)(result));
10572 return resultobj;
10573fail:
10574 return NULL;
10575}
10576
10577
10578SWIGINTERN PyObject *_wrap_plreplot(PyObject *self, PyObject *args) {
10579 PyObject *resultobj = 0;
10580
10581 (void)self;
10582 if (!SWIG_Python_UnpackTuple(args, "plreplot", 0, 0, 0)) SWIG_fail;
10583 plreplot();
10584 resultobj = SWIG_Py_Void();
10585 return resultobj;
10586fail:
10587 return NULL;
10588}
10589
10590
10591SWIGINTERN PyObject *_wrap_plrgbhls(PyObject *self, PyObject *args) {
10592 PyObject *resultobj = 0;
10593 PLFLT arg1 ;
10594 PLFLT arg2 ;
10595 PLFLT arg3 ;
10596 PLFLT *arg4 = (PLFLT *) 0 ;
10597 PLFLT *arg5 = (PLFLT *) 0 ;
10598 PLFLT *arg6 = (PLFLT *) 0 ;
10599 double val1 ;
10600 int ecode1 = 0 ;
10601 double val2 ;
10602 int ecode2 = 0 ;
10603 double val3 ;
10604 int ecode3 = 0 ;
10605 PLFLT temp4 ;
10606 int res4 = SWIG_TMPOBJ ;
10607 PLFLT temp5 ;
10608 int res5 = SWIG_TMPOBJ ;
10609 PLFLT temp6 ;
10610 int res6 = SWIG_TMPOBJ ;
10611 PyObject *swig_obj[3] ;
10612
10613 arg4 = &temp4;
10614 arg5 = &temp5;
10615 arg6 = &temp6;
10616 (void)self;
10617 if (!SWIG_Python_UnpackTuple(args, "plrgbhls", 3, 3, swig_obj)) SWIG_fail;
10618 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10619 if (!SWIG_IsOK(ecode1)) {
10620 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
10621 }
10622 arg1 = (PLFLT)(val1);
10623 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10624 if (!SWIG_IsOK(ecode2)) {
10625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
10626 }
10627 arg2 = (PLFLT)(val2);
10628 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
10629 if (!SWIG_IsOK(ecode3)) {
10630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
10631 }
10632 arg3 = (PLFLT)(val3);
10633 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
10634 resultobj = SWIG_Py_Void();
10635 if (SWIG_IsTmpObj(res4)) {
10636 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
10637 } else {
10638 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
10640 }
10641 if (SWIG_IsTmpObj(res5)) {
10642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
10643 } else {
10644 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
10646 }
10647 if (SWIG_IsTmpObj(res6)) {
10648 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 1);
10649 } else {
10650 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10651 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 1);
10652 }
10653 return resultobj;
10654fail:
10655 return NULL;
10656}
10657
10658
10659SWIGINTERN PyObject *_wrap_plschr(PyObject *self, PyObject *args) {
10660 PyObject *resultobj = 0;
10661 PLFLT arg1 ;
10662 PLFLT arg2 ;
10663 double val1 ;
10664 int ecode1 = 0 ;
10665 double val2 ;
10666 int ecode2 = 0 ;
10667 PyObject *swig_obj[2] ;
10668
10669 (void)self;
10670 if (!SWIG_Python_UnpackTuple(args, "plschr", 2, 2, swig_obj)) SWIG_fail;
10671 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
10672 if (!SWIG_IsOK(ecode1)) {
10673 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
10674 }
10675 arg1 = (PLFLT)(val1);
10676 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
10677 if (!SWIG_IsOK(ecode2)) {
10678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
10679 }
10680 arg2 = (PLFLT)(val2);
10681 plschr(arg1,arg2);
10682 resultobj = SWIG_Py_Void();
10683 return resultobj;
10684fail:
10685 return NULL;
10686}
10687
10688
10689SWIGINTERN PyObject *_wrap_plscmap0(PyObject *self, PyObject *args) {
10690 PyObject *resultobj = 0;
10691 PLINT *arg1 = (PLINT *) 0 ;
10692 PLINT *arg2 = (PLINT *) 0 ;
10693 PLINT *arg3 = (PLINT *) 0 ;
10694 PLINT arg4 ;
10695 PyArrayObject *tmp1 = NULL ;
10696 PyArrayObject *tmp2 = NULL ;
10697 PyArrayObject *tmp3 = NULL ;
10698 PyObject *swig_obj[3] ;
10699
10700 (void)self;
10701 if (!SWIG_Python_UnpackTuple(args, "plscmap0", 3, 3, swig_obj)) SWIG_fail;
10702 {
10703 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10704 if ( tmp1 == NULL )
10705 return NULL;
10706 Alen = PyArray_DIMS( tmp1 )[0];
10707 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10708 }
10709 {
10710 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10711 if ( tmp2 == NULL )
10712 return NULL;
10713 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10714 {
10715 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10716 return NULL;
10717 }
10718 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10719 }
10720 {
10721 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10722 if ( tmp3 == NULL )
10723 return NULL;
10724 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10725 {
10726 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10727 return NULL;
10728 }
10729 arg4 = PyArray_DIMS( tmp3 )[0];
10730 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10731 }
10732 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10733 resultobj = SWIG_Py_Void();
10734 {
10735 Py_CLEAR( tmp1 );
10736 }
10737 {
10738 Py_CLEAR( tmp2 );
10739 }
10740 {
10741 Py_CLEAR( tmp3 );
10742 }
10743 return resultobj;
10744fail:
10745 {
10746 Py_CLEAR( tmp1 );
10747 }
10748 {
10749 Py_CLEAR( tmp2 );
10750 }
10751 {
10752 Py_CLEAR( tmp3 );
10753 }
10754 return NULL;
10755}
10756
10757
10758SWIGINTERN PyObject *_wrap_plscmap0a(PyObject *self, PyObject *args) {
10759 PyObject *resultobj = 0;
10760 PLINT *arg1 = (PLINT *) 0 ;
10761 PLINT *arg2 = (PLINT *) 0 ;
10762 PLINT *arg3 = (PLINT *) 0 ;
10763 PLFLT *arg4 = (PLFLT *) 0 ;
10764 PLINT arg5 ;
10765 PyArrayObject *tmp1 = NULL ;
10766 PyArrayObject *tmp2 = NULL ;
10767 PyArrayObject *tmp3 = NULL ;
10768 PyArrayObject *tmp4 = NULL ;
10769 PyObject *swig_obj[4] ;
10770
10771 (void)self;
10772 if (!SWIG_Python_UnpackTuple(args, "plscmap0a", 4, 4, swig_obj)) SWIG_fail;
10773 {
10774 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10775 if ( tmp1 == NULL )
10776 return NULL;
10777 Alen = PyArray_DIMS( tmp1 )[0];
10778 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10779 }
10780 {
10781 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10782 if ( tmp2 == NULL )
10783 return NULL;
10784 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10785 {
10786 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10787 return NULL;
10788 }
10789 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10790 }
10791 {
10792 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10793 if ( tmp3 == NULL )
10794 return NULL;
10795 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10796 {
10797 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10798 return NULL;
10799 }
10800 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10801 }
10802 {
10803 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10804 if ( tmp4 == NULL )
10805 return NULL;
10806 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10807 {
10808 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10809 return NULL;
10810 }
10811 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10812 arg5 = PyArray_DIMS( tmp4 )[0];
10813 }
10814 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10815 resultobj = SWIG_Py_Void();
10816 {
10817 Py_CLEAR( tmp1 );
10818 }
10819 {
10820 Py_CLEAR( tmp2 );
10821 }
10822 {
10823 Py_CLEAR( tmp3 );
10824 }
10825 {
10826 Py_CLEAR( tmp4 );
10827 }
10828 return resultobj;
10829fail:
10830 {
10831 Py_CLEAR( tmp1 );
10832 }
10833 {
10834 Py_CLEAR( tmp2 );
10835 }
10836 {
10837 Py_CLEAR( tmp3 );
10838 }
10839 {
10840 Py_CLEAR( tmp4 );
10841 }
10842 return NULL;
10843}
10844
10845
10846SWIGINTERN PyObject *_wrap_plscmap0n(PyObject *self, PyObject *args) {
10847 PyObject *resultobj = 0;
10848 PLINT arg1 ;
10849 int val1 ;
10850 int ecode1 = 0 ;
10851 PyObject *swig_obj[1] ;
10852
10853 (void)self;
10854 if (!args) SWIG_fail;
10855 swig_obj[0] = args;
10856 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
10857 if (!SWIG_IsOK(ecode1)) {
10858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
10859 }
10860 arg1 = (PLINT)(val1);
10861 plscmap0n(arg1);
10862 resultobj = SWIG_Py_Void();
10863 return resultobj;
10864fail:
10865 return NULL;
10866}
10867
10868
10869SWIGINTERN PyObject *_wrap_plscmap1(PyObject *self, PyObject *args) {
10870 PyObject *resultobj = 0;
10871 PLINT *arg1 = (PLINT *) 0 ;
10872 PLINT *arg2 = (PLINT *) 0 ;
10873 PLINT *arg3 = (PLINT *) 0 ;
10874 PLINT arg4 ;
10875 PyArrayObject *tmp1 = NULL ;
10876 PyArrayObject *tmp2 = NULL ;
10877 PyArrayObject *tmp3 = NULL ;
10878 PyObject *swig_obj[3] ;
10879
10880 (void)self;
10881 if (!SWIG_Python_UnpackTuple(args, "plscmap1", 3, 3, swig_obj)) SWIG_fail;
10882 {
10883 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10884 if ( tmp1 == NULL )
10885 return NULL;
10886 Alen = PyArray_DIMS( tmp1 )[0];
10887 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10888 }
10889 {
10890 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10891 if ( tmp2 == NULL )
10892 return NULL;
10893 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10894 {
10895 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10896 return NULL;
10897 }
10898 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10899 }
10900 {
10901 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10902 if ( tmp3 == NULL )
10903 return NULL;
10904 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10905 {
10906 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10907 return NULL;
10908 }
10909 arg4 = PyArray_DIMS( tmp3 )[0];
10910 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10911 }
10912 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
10913 resultobj = SWIG_Py_Void();
10914 {
10915 Py_CLEAR( tmp1 );
10916 }
10917 {
10918 Py_CLEAR( tmp2 );
10919 }
10920 {
10921 Py_CLEAR( tmp3 );
10922 }
10923 return resultobj;
10924fail:
10925 {
10926 Py_CLEAR( tmp1 );
10927 }
10928 {
10929 Py_CLEAR( tmp2 );
10930 }
10931 {
10932 Py_CLEAR( tmp3 );
10933 }
10934 return NULL;
10935}
10936
10937
10938SWIGINTERN PyObject *_wrap_plscmap1a(PyObject *self, PyObject *args) {
10939 PyObject *resultobj = 0;
10940 PLINT *arg1 = (PLINT *) 0 ;
10941 PLINT *arg2 = (PLINT *) 0 ;
10942 PLINT *arg3 = (PLINT *) 0 ;
10943 PLFLT *arg4 = (PLFLT *) 0 ;
10944 PLINT arg5 ;
10945 PyArrayObject *tmp1 = NULL ;
10946 PyArrayObject *tmp2 = NULL ;
10947 PyArrayObject *tmp3 = NULL ;
10948 PyArrayObject *tmp4 = NULL ;
10949 PyObject *swig_obj[4] ;
10950
10951 (void)self;
10952 if (!SWIG_Python_UnpackTuple(args, "plscmap1a", 4, 4, swig_obj)) SWIG_fail;
10953 {
10954 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
10955 if ( tmp1 == NULL )
10956 return NULL;
10957 Alen = PyArray_DIMS( tmp1 )[0];
10958 arg1 = (PLINT *) PyArray_DATA( tmp1 );
10959 }
10960 {
10961 tmp2 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
10962 if ( tmp2 == NULL )
10963 return NULL;
10964 if ( PyArray_DIMS( tmp2 )[0] != Alen )
10965 {
10966 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10967 return NULL;
10968 }
10969 arg2 = (PLINT *) PyArray_DATA( tmp2 );
10970 }
10971 {
10972 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[2], NPY_PLINT, 1, 1 );
10973 if ( tmp3 == NULL )
10974 return NULL;
10975 if ( PyArray_DIMS( tmp3 )[0] != Alen )
10976 {
10977 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10978 return NULL;
10979 }
10980 arg3 = (PLINT *) PyArray_DATA( tmp3 );
10981 }
10982 {
10983 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
10984 if ( tmp4 == NULL )
10985 return NULL;
10986 if ( PyArray_DIMS( tmp4 )[0] != Alen )
10987 {
10988 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
10989 return NULL;
10990 }
10991 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
10992 arg5 = PyArray_DIMS( tmp4 )[0];
10993 }
10994 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
10995 resultobj = SWIG_Py_Void();
10996 {
10997 Py_CLEAR( tmp1 );
10998 }
10999 {
11000 Py_CLEAR( tmp2 );
11001 }
11002 {
11003 Py_CLEAR( tmp3 );
11004 }
11005 {
11006 Py_CLEAR( tmp4 );
11007 }
11008 return resultobj;
11009fail:
11010 {
11011 Py_CLEAR( tmp1 );
11012 }
11013 {
11014 Py_CLEAR( tmp2 );
11015 }
11016 {
11017 Py_CLEAR( tmp3 );
11018 }
11019 {
11020 Py_CLEAR( tmp4 );
11021 }
11022 return NULL;
11023}
11024
11025
11026SWIGINTERN PyObject *_wrap_plscmap1l(PyObject *self, PyObject *args) {
11027 PyObject *resultobj = 0;
11028 PLBOOL arg1 ;
11029 PLINT arg2 ;
11030 PLFLT *arg3 = (PLFLT *) 0 ;
11031 PLFLT *arg4 = (PLFLT *) 0 ;
11032 PLFLT *arg5 = (PLFLT *) 0 ;
11033 PLFLT *arg6 = (PLFLT *) 0 ;
11034 PLBOOL *arg7 = (PLBOOL *) 0 ;
11035 int val1 ;
11036 int ecode1 = 0 ;
11037 PyArrayObject *tmp2 = NULL ;
11038 PyArrayObject *tmp4 = NULL ;
11039 PyArrayObject *tmp5 = NULL ;
11040 PyArrayObject *tmp6 = NULL ;
11041 PyArrayObject *tmp7 = NULL ;
11042 PyObject *swig_obj[6] ;
11043
11044 (void)self;
11045 if (!SWIG_Python_UnpackTuple(args, "plscmap1l", 6, 6, swig_obj)) SWIG_fail;
11046 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11047 if (!SWIG_IsOK(ecode1)) {
11048 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
11049 }
11050 arg1 = (PLBOOL)(val1);
11051 {
11052 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11053 if ( tmp2 == NULL )
11054 return NULL;
11055 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11056 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11057 }
11058 {
11059 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11060 if ( tmp4 == NULL )
11061 return NULL;
11062 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11063 {
11064 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11065 return NULL;
11066 }
11067 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11068 }
11069 {
11070 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11071 if ( tmp5 == NULL )
11072 return NULL;
11073 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11074 {
11075 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11076 return NULL;
11077 }
11078 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11079 }
11080 {
11081 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11082 if ( tmp6 == NULL )
11083 return NULL;
11084 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11085 {
11086 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11087 return NULL;
11088 }
11089 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11090 }
11091 {
11092 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[5], NPY_PLINT, 1, 1 );
11093 if ( tmp7 == NULL )
11094 return NULL;
11095 if ( PyArray_DIMS( tmp7 )[0] < Alen - 1 )
11096 {
11097 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11098 return NULL;
11099 }
11100 arg7 = (PLINT *) PyArray_DATA( tmp7 );
11101 }
11102 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
11103 resultobj = SWIG_Py_Void();
11104 {
11105 Py_CLEAR( tmp2 );
11106 }
11107 {
11108 Py_CLEAR( tmp4 );
11109 }
11110 {
11111 Py_CLEAR( tmp5 );
11112 }
11113 {
11114 Py_CLEAR( tmp6 );
11115 }
11116 {
11117 Py_CLEAR( tmp7 );
11118 }
11119 return resultobj;
11120fail:
11121 {
11122 Py_CLEAR( tmp2 );
11123 }
11124 {
11125 Py_CLEAR( tmp4 );
11126 }
11127 {
11128 Py_CLEAR( tmp5 );
11129 }
11130 {
11131 Py_CLEAR( tmp6 );
11132 }
11133 {
11134 Py_CLEAR( tmp7 );
11135 }
11136 return NULL;
11137}
11138
11139
11140SWIGINTERN PyObject *_wrap_plscmap1la(PyObject *self, PyObject *args) {
11141 PyObject *resultobj = 0;
11142 PLBOOL arg1 ;
11143 PLINT arg2 ;
11144 PLFLT *arg3 = (PLFLT *) 0 ;
11145 PLFLT *arg4 = (PLFLT *) 0 ;
11146 PLFLT *arg5 = (PLFLT *) 0 ;
11147 PLFLT *arg6 = (PLFLT *) 0 ;
11148 PLFLT *arg7 = (PLFLT *) 0 ;
11149 PLBOOL *arg8 = (PLBOOL *) 0 ;
11150 int val1 ;
11151 int ecode1 = 0 ;
11152 PyArrayObject *tmp2 = NULL ;
11153 PyArrayObject *tmp4 = NULL ;
11154 PyArrayObject *tmp5 = NULL ;
11155 PyArrayObject *tmp6 = NULL ;
11156 PyArrayObject *tmp7 = NULL ;
11157 PyArrayObject *tmp8 = NULL ;
11158 PyObject *swig_obj[7] ;
11159
11160 (void)self;
11161 if (!SWIG_Python_UnpackTuple(args, "plscmap1la", 7, 7, swig_obj)) SWIG_fail;
11162 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11163 if (!SWIG_IsOK(ecode1)) {
11164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
11165 }
11166 arg1 = (PLBOOL)(val1);
11167 {
11168 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
11169 if ( tmp2 == NULL )
11170 return NULL;
11171 arg2 = Alen = PyArray_DIMS( tmp2 )[0];
11172 arg3 = (PLFLT *) PyArray_DATA( tmp2 );
11173 }
11174 {
11175 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
11176 if ( tmp4 == NULL )
11177 return NULL;
11178 if ( PyArray_DIMS( tmp4 )[0] != Alen )
11179 {
11180 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11181 return NULL;
11182 }
11183 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
11184 }
11185 {
11186 tmp5 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[3], NPY_PLFLT, 1, 1 );
11187 if ( tmp5 == NULL )
11188 return NULL;
11189 if ( PyArray_DIMS( tmp5 )[0] != Alen )
11190 {
11191 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11192 return NULL;
11193 }
11194 arg5 = (PLFLT *) PyArray_DATA( tmp5 );
11195 }
11196 {
11197 tmp6 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[4], NPY_PLFLT, 1, 1 );
11198 if ( tmp6 == NULL )
11199 return NULL;
11200 if ( PyArray_DIMS( tmp6 )[0] != Alen )
11201 {
11202 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11203 return NULL;
11204 }
11205 arg6 = (PLFLT *) PyArray_DATA( tmp6 );
11206 }
11207 {
11208 tmp7 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
11209 if ( tmp7 == NULL )
11210 return NULL;
11211 if ( PyArray_DIMS( tmp7 )[0] != Alen )
11212 {
11213 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
11214 return NULL;
11215 }
11216 arg7 = (PLFLT *) PyArray_DATA( tmp7 );
11217 }
11218 {
11219 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
11220 if ( tmp8 == NULL )
11221 return NULL;
11222 if ( PyArray_DIMS( tmp8 )[0] < Alen - 1 )
11223 {
11224 PyErr_SetString( PyExc_ValueError, "Vector must be at least length of others minus 1." );
11225 return NULL;
11226 }
11227 arg8 = (PLINT *) PyArray_DATA( tmp8 );
11228 }
11229 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
11230 resultobj = SWIG_Py_Void();
11231 {
11232 Py_CLEAR( tmp2 );
11233 }
11234 {
11235 Py_CLEAR( tmp4 );
11236 }
11237 {
11238 Py_CLEAR( tmp5 );
11239 }
11240 {
11241 Py_CLEAR( tmp6 );
11242 }
11243 {
11244 Py_CLEAR( tmp7 );
11245 }
11246 {
11247 Py_CLEAR( tmp8 );
11248 }
11249 return resultobj;
11250fail:
11251 {
11252 Py_CLEAR( tmp2 );
11253 }
11254 {
11255 Py_CLEAR( tmp4 );
11256 }
11257 {
11258 Py_CLEAR( tmp5 );
11259 }
11260 {
11261 Py_CLEAR( tmp6 );
11262 }
11263 {
11264 Py_CLEAR( tmp7 );
11265 }
11266 {
11267 Py_CLEAR( tmp8 );
11268 }
11269 return NULL;
11270}
11271
11272
11273SWIGINTERN PyObject *_wrap_plscmap1n(PyObject *self, PyObject *args) {
11274 PyObject *resultobj = 0;
11275 PLINT arg1 ;
11276 int val1 ;
11277 int ecode1 = 0 ;
11278 PyObject *swig_obj[1] ;
11279
11280 (void)self;
11281 if (!args) SWIG_fail;
11282 swig_obj[0] = args;
11283 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11284 if (!SWIG_IsOK(ecode1)) {
11285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
11286 }
11287 arg1 = (PLINT)(val1);
11288 plscmap1n(arg1);
11289 resultobj = SWIG_Py_Void();
11290 return resultobj;
11291fail:
11292 return NULL;
11293}
11294
11295
11296SWIGINTERN PyObject *_wrap_plscmap1_range(PyObject *self, PyObject *args) {
11297 PyObject *resultobj = 0;
11298 PLFLT arg1 ;
11299 PLFLT arg2 ;
11300 double val1 ;
11301 int ecode1 = 0 ;
11302 double val2 ;
11303 int ecode2 = 0 ;
11304 PyObject *swig_obj[2] ;
11305
11306 (void)self;
11307 if (!SWIG_Python_UnpackTuple(args, "plscmap1_range", 2, 2, swig_obj)) SWIG_fail;
11308 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11309 if (!SWIG_IsOK(ecode1)) {
11310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
11311 }
11312 arg1 = (PLFLT)(val1);
11313 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11314 if (!SWIG_IsOK(ecode2)) {
11315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
11316 }
11317 arg2 = (PLFLT)(val2);
11318 plscmap1_range(arg1,arg2);
11319 resultobj = SWIG_Py_Void();
11320 return resultobj;
11321fail:
11322 return NULL;
11323}
11324
11325
11326SWIGINTERN PyObject *_wrap_plgcmap1_range(PyObject *self, PyObject *args) {
11327 PyObject *resultobj = 0;
11328 PLFLT *arg1 = (PLFLT *) 0 ;
11329 PLFLT *arg2 = (PLFLT *) 0 ;
11330 PLFLT temp1 ;
11331 int res1 = SWIG_TMPOBJ ;
11332 PLFLT temp2 ;
11333 int res2 = SWIG_TMPOBJ ;
11334
11335 arg1 = &temp1;
11336 arg2 = &temp2;
11337 (void)self;
11338 if (!SWIG_Python_UnpackTuple(args, "plgcmap1_range", 0, 0, 0)) SWIG_fail;
11339 plgcmap1_range(arg1,arg2);
11340 resultobj = SWIG_Py_Void();
11341 if (SWIG_IsTmpObj(res1)) {
11342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg1)), 1);
11343 } else {
11344 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11345 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags), 1);
11346 }
11347 if (SWIG_IsTmpObj(res2)) {
11348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 1);
11349 } else {
11350 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 1);
11352 }
11353 return resultobj;
11354fail:
11355 return NULL;
11356}
11357
11358
11359SWIGINTERN PyObject *_wrap_plscol0(PyObject *self, PyObject *args) {
11360 PyObject *resultobj = 0;
11361 PLINT arg1 ;
11362 PLINT arg2 ;
11363 PLINT arg3 ;
11364 PLINT arg4 ;
11365 int val1 ;
11366 int ecode1 = 0 ;
11367 int val2 ;
11368 int ecode2 = 0 ;
11369 int val3 ;
11370 int ecode3 = 0 ;
11371 int val4 ;
11372 int ecode4 = 0 ;
11373 PyObject *swig_obj[4] ;
11374
11375 (void)self;
11376 if (!SWIG_Python_UnpackTuple(args, "plscol0", 4, 4, swig_obj)) SWIG_fail;
11377 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11378 if (!SWIG_IsOK(ecode1)) {
11379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
11380 }
11381 arg1 = (PLINT)(val1);
11382 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11383 if (!SWIG_IsOK(ecode2)) {
11384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
11385 }
11386 arg2 = (PLINT)(val2);
11387 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11388 if (!SWIG_IsOK(ecode3)) {
11389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
11390 }
11391 arg3 = (PLINT)(val3);
11392 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11393 if (!SWIG_IsOK(ecode4)) {
11394 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
11395 }
11396 arg4 = (PLINT)(val4);
11397 plscol0(arg1,arg2,arg3,arg4);
11398 resultobj = SWIG_Py_Void();
11399 return resultobj;
11400fail:
11401 return NULL;
11402}
11403
11404
11405SWIGINTERN PyObject *_wrap_plscol0a(PyObject *self, PyObject *args) {
11406 PyObject *resultobj = 0;
11407 PLINT arg1 ;
11408 PLINT arg2 ;
11409 PLINT arg3 ;
11410 PLINT arg4 ;
11411 PLFLT arg5 ;
11412 int val1 ;
11413 int ecode1 = 0 ;
11414 int val2 ;
11415 int ecode2 = 0 ;
11416 int val3 ;
11417 int ecode3 = 0 ;
11418 int val4 ;
11419 int ecode4 = 0 ;
11420 double val5 ;
11421 int ecode5 = 0 ;
11422 PyObject *swig_obj[5] ;
11423
11424 (void)self;
11425 if (!SWIG_Python_UnpackTuple(args, "plscol0a", 5, 5, swig_obj)) SWIG_fail;
11426 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11427 if (!SWIG_IsOK(ecode1)) {
11428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
11429 }
11430 arg1 = (PLINT)(val1);
11431 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11432 if (!SWIG_IsOK(ecode2)) {
11433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
11434 }
11435 arg2 = (PLINT)(val2);
11436 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11437 if (!SWIG_IsOK(ecode3)) {
11438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
11439 }
11440 arg3 = (PLINT)(val3);
11441 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11442 if (!SWIG_IsOK(ecode4)) {
11443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
11444 }
11445 arg4 = (PLINT)(val4);
11446 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11447 if (!SWIG_IsOK(ecode5)) {
11448 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
11449 }
11450 arg5 = (PLFLT)(val5);
11451 plscol0a(arg1,arg2,arg3,arg4,arg5);
11452 resultobj = SWIG_Py_Void();
11453 return resultobj;
11454fail:
11455 return NULL;
11456}
11457
11458
11459SWIGINTERN PyObject *_wrap_plscolbg(PyObject *self, PyObject *args) {
11460 PyObject *resultobj = 0;
11461 PLINT arg1 ;
11462 PLINT arg2 ;
11463 PLINT arg3 ;
11464 int val1 ;
11465 int ecode1 = 0 ;
11466 int val2 ;
11467 int ecode2 = 0 ;
11468 int val3 ;
11469 int ecode3 = 0 ;
11470 PyObject *swig_obj[3] ;
11471
11472 (void)self;
11473 if (!SWIG_Python_UnpackTuple(args, "plscolbg", 3, 3, swig_obj)) SWIG_fail;
11474 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11475 if (!SWIG_IsOK(ecode1)) {
11476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
11477 }
11478 arg1 = (PLINT)(val1);
11479 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11480 if (!SWIG_IsOK(ecode2)) {
11481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
11482 }
11483 arg2 = (PLINT)(val2);
11484 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11485 if (!SWIG_IsOK(ecode3)) {
11486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
11487 }
11488 arg3 = (PLINT)(val3);
11489 plscolbg(arg1,arg2,arg3);
11490 resultobj = SWIG_Py_Void();
11491 return resultobj;
11492fail:
11493 return NULL;
11494}
11495
11496
11497SWIGINTERN PyObject *_wrap_plscolbga(PyObject *self, PyObject *args) {
11498 PyObject *resultobj = 0;
11499 PLINT arg1 ;
11500 PLINT arg2 ;
11501 PLINT arg3 ;
11502 PLFLT arg4 ;
11503 int val1 ;
11504 int ecode1 = 0 ;
11505 int val2 ;
11506 int ecode2 = 0 ;
11507 int val3 ;
11508 int ecode3 = 0 ;
11509 double val4 ;
11510 int ecode4 = 0 ;
11511 PyObject *swig_obj[4] ;
11512
11513 (void)self;
11514 if (!SWIG_Python_UnpackTuple(args, "plscolbga", 4, 4, swig_obj)) SWIG_fail;
11515 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11516 if (!SWIG_IsOK(ecode1)) {
11517 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
11518 }
11519 arg1 = (PLINT)(val1);
11520 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11521 if (!SWIG_IsOK(ecode2)) {
11522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
11523 }
11524 arg2 = (PLINT)(val2);
11525 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11526 if (!SWIG_IsOK(ecode3)) {
11527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
11528 }
11529 arg3 = (PLINT)(val3);
11530 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11531 if (!SWIG_IsOK(ecode4)) {
11532 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
11533 }
11534 arg4 = (PLFLT)(val4);
11535 plscolbga(arg1,arg2,arg3,arg4);
11536 resultobj = SWIG_Py_Void();
11537 return resultobj;
11538fail:
11539 return NULL;
11540}
11541
11542
11543SWIGINTERN PyObject *_wrap_plscolor(PyObject *self, PyObject *args) {
11544 PyObject *resultobj = 0;
11545 PLINT arg1 ;
11546 int val1 ;
11547 int ecode1 = 0 ;
11548 PyObject *swig_obj[1] ;
11549
11550 (void)self;
11551 if (!args) SWIG_fail;
11552 swig_obj[0] = args;
11553 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11554 if (!SWIG_IsOK(ecode1)) {
11555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
11556 }
11557 arg1 = (PLINT)(val1);
11558 plscolor(arg1);
11559 resultobj = SWIG_Py_Void();
11560 return resultobj;
11561fail:
11562 return NULL;
11563}
11564
11565
11566SWIGINTERN PyObject *_wrap_plscompression(PyObject *self, PyObject *args) {
11567 PyObject *resultobj = 0;
11568 PLINT arg1 ;
11569 int val1 ;
11570 int ecode1 = 0 ;
11571 PyObject *swig_obj[1] ;
11572
11573 (void)self;
11574 if (!args) SWIG_fail;
11575 swig_obj[0] = args;
11576 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11577 if (!SWIG_IsOK(ecode1)) {
11578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
11579 }
11580 arg1 = (PLINT)(val1);
11581 plscompression(arg1);
11582 resultobj = SWIG_Py_Void();
11583 return resultobj;
11584fail:
11585 return NULL;
11586}
11587
11588
11589SWIGINTERN PyObject *_wrap_plsdev(PyObject *self, PyObject *args) {
11590 PyObject *resultobj = 0;
11591 char *arg1 = (char *) 0 ;
11592 int res1 ;
11593 char *buf1 = 0 ;
11594 int alloc1 = 0 ;
11595 PyObject *swig_obj[1] ;
11596
11597 (void)self;
11598 if (!args) SWIG_fail;
11599 swig_obj[0] = args;
11600 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11601 if (!SWIG_IsOK(res1)) {
11602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
11603 }
11604 arg1 = (char *)(buf1);
11605 plsdev((char const *)arg1);
11606 resultobj = SWIG_Py_Void();
11607 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11608 return resultobj;
11609fail:
11610 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11611 return NULL;
11612}
11613
11614
11615SWIGINTERN PyObject *_wrap_plsdidev(PyObject *self, PyObject *args) {
11616 PyObject *resultobj = 0;
11617 PLFLT arg1 ;
11618 PLFLT arg2 ;
11619 PLFLT arg3 ;
11620 PLFLT arg4 ;
11621 double val1 ;
11622 int ecode1 = 0 ;
11623 double val2 ;
11624 int ecode2 = 0 ;
11625 double val3 ;
11626 int ecode3 = 0 ;
11627 double val4 ;
11628 int ecode4 = 0 ;
11629 PyObject *swig_obj[4] ;
11630
11631 (void)self;
11632 if (!SWIG_Python_UnpackTuple(args, "plsdidev", 4, 4, swig_obj)) SWIG_fail;
11633 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11634 if (!SWIG_IsOK(ecode1)) {
11635 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
11636 }
11637 arg1 = (PLFLT)(val1);
11638 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11639 if (!SWIG_IsOK(ecode2)) {
11640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
11641 }
11642 arg2 = (PLFLT)(val2);
11643 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11644 if (!SWIG_IsOK(ecode3)) {
11645 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
11646 }
11647 arg3 = (PLFLT)(val3);
11648 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11649 if (!SWIG_IsOK(ecode4)) {
11650 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
11651 }
11652 arg4 = (PLFLT)(val4);
11653 plsdidev(arg1,arg2,arg3,arg4);
11654 resultobj = SWIG_Py_Void();
11655 return resultobj;
11656fail:
11657 return NULL;
11658}
11659
11660
11661SWIGINTERN PyObject *_wrap_plsdimap(PyObject *self, PyObject *args) {
11662 PyObject *resultobj = 0;
11663 PLINT arg1 ;
11664 PLINT arg2 ;
11665 PLINT arg3 ;
11666 PLINT arg4 ;
11667 PLFLT arg5 ;
11668 PLFLT arg6 ;
11669 int val1 ;
11670 int ecode1 = 0 ;
11671 int val2 ;
11672 int ecode2 = 0 ;
11673 int val3 ;
11674 int ecode3 = 0 ;
11675 int val4 ;
11676 int ecode4 = 0 ;
11677 double val5 ;
11678 int ecode5 = 0 ;
11679 double val6 ;
11680 int ecode6 = 0 ;
11681 PyObject *swig_obj[6] ;
11682
11683 (void)self;
11684 if (!SWIG_Python_UnpackTuple(args, "plsdimap", 6, 6, swig_obj)) SWIG_fail;
11685 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11686 if (!SWIG_IsOK(ecode1)) {
11687 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
11688 }
11689 arg1 = (PLINT)(val1);
11690 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11691 if (!SWIG_IsOK(ecode2)) {
11692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
11693 }
11694 arg2 = (PLINT)(val2);
11695 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11696 if (!SWIG_IsOK(ecode3)) {
11697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
11698 }
11699 arg3 = (PLINT)(val3);
11700 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
11701 if (!SWIG_IsOK(ecode4)) {
11702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
11703 }
11704 arg4 = (PLINT)(val4);
11705 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
11706 if (!SWIG_IsOK(ecode5)) {
11707 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
11708 }
11709 arg5 = (PLFLT)(val5);
11710 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
11711 if (!SWIG_IsOK(ecode6)) {
11712 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
11713 }
11714 arg6 = (PLFLT)(val6);
11715 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
11716 resultobj = SWIG_Py_Void();
11717 return resultobj;
11718fail:
11719 return NULL;
11720}
11721
11722
11723SWIGINTERN PyObject *_wrap_plsdiori(PyObject *self, PyObject *args) {
11724 PyObject *resultobj = 0;
11725 PLFLT arg1 ;
11726 double val1 ;
11727 int ecode1 = 0 ;
11728 PyObject *swig_obj[1] ;
11729
11730 (void)self;
11731 if (!args) SWIG_fail;
11732 swig_obj[0] = args;
11733 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11734 if (!SWIG_IsOK(ecode1)) {
11735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
11736 }
11737 arg1 = (PLFLT)(val1);
11738 plsdiori(arg1);
11739 resultobj = SWIG_Py_Void();
11740 return resultobj;
11741fail:
11742 return NULL;
11743}
11744
11745
11746SWIGINTERN PyObject *_wrap_plsdiplt(PyObject *self, PyObject *args) {
11747 PyObject *resultobj = 0;
11748 PLFLT arg1 ;
11749 PLFLT arg2 ;
11750 PLFLT arg3 ;
11751 PLFLT arg4 ;
11752 double val1 ;
11753 int ecode1 = 0 ;
11754 double val2 ;
11755 int ecode2 = 0 ;
11756 double val3 ;
11757 int ecode3 = 0 ;
11758 double val4 ;
11759 int ecode4 = 0 ;
11760 PyObject *swig_obj[4] ;
11761
11762 (void)self;
11763 if (!SWIG_Python_UnpackTuple(args, "plsdiplt", 4, 4, swig_obj)) SWIG_fail;
11764 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11765 if (!SWIG_IsOK(ecode1)) {
11766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
11767 }
11768 arg1 = (PLFLT)(val1);
11769 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11770 if (!SWIG_IsOK(ecode2)) {
11771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
11772 }
11773 arg2 = (PLFLT)(val2);
11774 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11775 if (!SWIG_IsOK(ecode3)) {
11776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
11777 }
11778 arg3 = (PLFLT)(val3);
11779 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11780 if (!SWIG_IsOK(ecode4)) {
11781 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
11782 }
11783 arg4 = (PLFLT)(val4);
11784 plsdiplt(arg1,arg2,arg3,arg4);
11785 resultobj = SWIG_Py_Void();
11786 return resultobj;
11787fail:
11788 return NULL;
11789}
11790
11791
11792SWIGINTERN PyObject *_wrap_plsdiplz(PyObject *self, PyObject *args) {
11793 PyObject *resultobj = 0;
11794 PLFLT arg1 ;
11795 PLFLT arg2 ;
11796 PLFLT arg3 ;
11797 PLFLT arg4 ;
11798 double val1 ;
11799 int ecode1 = 0 ;
11800 double val2 ;
11801 int ecode2 = 0 ;
11802 double val3 ;
11803 int ecode3 = 0 ;
11804 double val4 ;
11805 int ecode4 = 0 ;
11806 PyObject *swig_obj[4] ;
11807
11808 (void)self;
11809 if (!SWIG_Python_UnpackTuple(args, "plsdiplz", 4, 4, swig_obj)) SWIG_fail;
11810 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
11811 if (!SWIG_IsOK(ecode1)) {
11812 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
11813 }
11814 arg1 = (PLFLT)(val1);
11815 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
11816 if (!SWIG_IsOK(ecode2)) {
11817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
11818 }
11819 arg2 = (PLFLT)(val2);
11820 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
11821 if (!SWIG_IsOK(ecode3)) {
11822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
11823 }
11824 arg3 = (PLFLT)(val3);
11825 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
11826 if (!SWIG_IsOK(ecode4)) {
11827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
11828 }
11829 arg4 = (PLFLT)(val4);
11830 plsdiplz(arg1,arg2,arg3,arg4);
11831 resultobj = SWIG_Py_Void();
11832 return resultobj;
11833fail:
11834 return NULL;
11835}
11836
11837
11838SWIGINTERN PyObject *_wrap_plseed(PyObject *self, PyObject *args) {
11839 PyObject *resultobj = 0;
11840 unsigned int arg1 ;
11841 unsigned int val1 ;
11842 int ecode1 = 0 ;
11843 PyObject *swig_obj[1] ;
11844
11845 (void)self;
11846 if (!args) SWIG_fail;
11847 swig_obj[0] = args;
11848 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11849 if (!SWIG_IsOK(ecode1)) {
11850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
11851 }
11852 arg1 = (unsigned int)(val1);
11853 plseed(arg1);
11854 resultobj = SWIG_Py_Void();
11855 return resultobj;
11856fail:
11857 return NULL;
11858}
11859
11860
11861SWIGINTERN PyObject *_wrap_plsesc(PyObject *self, PyObject *args) {
11862 PyObject *resultobj = 0;
11863 char arg1 ;
11864 char val1 ;
11865 int ecode1 = 0 ;
11866 PyObject *swig_obj[1] ;
11867
11868 (void)self;
11869 if (!args) SWIG_fail;
11870 swig_obj[0] = args;
11871 ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
11872 if (!SWIG_IsOK(ecode1)) {
11873 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
11874 }
11875 arg1 = (char)(val1);
11876 plsesc(arg1);
11877 resultobj = SWIG_Py_Void();
11878 return resultobj;
11879fail:
11880 return NULL;
11881}
11882
11883
11884SWIGINTERN PyObject *_wrap_plsetopt(PyObject *self, PyObject *args) {
11885 PyObject *resultobj = 0;
11886 char *arg1 = (char *) 0 ;
11887 char *arg2 = (char *) 0 ;
11888 int res1 ;
11889 char *buf1 = 0 ;
11890 int alloc1 = 0 ;
11891 int res2 ;
11892 char *buf2 = 0 ;
11893 int alloc2 = 0 ;
11894 PyObject *swig_obj[2] ;
11895 PLINT result;
11896
11897 (void)self;
11898 if (!SWIG_Python_UnpackTuple(args, "plsetopt", 2, 2, swig_obj)) SWIG_fail;
11899 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11900 if (!SWIG_IsOK(res1)) {
11901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsetopt" "', argument " "1"" of type '" "char const *""'");
11902 }
11903 arg1 = (char *)(buf1);
11904 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
11905 if (!SWIG_IsOK(res2)) {
11906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plsetopt" "', argument " "2"" of type '" "char const *""'");
11907 }
11908 arg2 = (char *)(buf2);
11909 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
11910 resultobj = SWIG_From_int((int)(result));
11911 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11912 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11913 return resultobj;
11914fail:
11915 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
11916 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11917 return NULL;
11918}
11919
11920
11921SWIGINTERN PyObject *_wrap_plsfam(PyObject *self, PyObject *args) {
11922 PyObject *resultobj = 0;
11923 PLINT arg1 ;
11924 PLINT arg2 ;
11925 PLINT arg3 ;
11926 int val1 ;
11927 int ecode1 = 0 ;
11928 int val2 ;
11929 int ecode2 = 0 ;
11930 int val3 ;
11931 int ecode3 = 0 ;
11932 PyObject *swig_obj[3] ;
11933
11934 (void)self;
11935 if (!SWIG_Python_UnpackTuple(args, "plsfam", 3, 3, swig_obj)) SWIG_fail;
11936 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
11937 if (!SWIG_IsOK(ecode1)) {
11938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
11939 }
11940 arg1 = (PLINT)(val1);
11941 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11942 if (!SWIG_IsOK(ecode2)) {
11943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
11944 }
11945 arg2 = (PLINT)(val2);
11946 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11947 if (!SWIG_IsOK(ecode3)) {
11948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
11949 }
11950 arg3 = (PLINT)(val3);
11951 plsfam(arg1,arg2,arg3);
11952 resultobj = SWIG_Py_Void();
11953 return resultobj;
11954fail:
11955 return NULL;
11956}
11957
11958
11959SWIGINTERN PyObject *_wrap_plsfci(PyObject *self, PyObject *args) {
11960 PyObject *resultobj = 0;
11961 PLUNICODE arg1 ;
11962 unsigned int val1 ;
11963 int ecode1 = 0 ;
11964 PyObject *swig_obj[1] ;
11965
11966 (void)self;
11967 if (!args) SWIG_fail;
11968 swig_obj[0] = args;
11969 ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
11970 if (!SWIG_IsOK(ecode1)) {
11971 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
11972 }
11973 arg1 = (PLUNICODE)(val1);
11974 plsfci(arg1);
11975 resultobj = SWIG_Py_Void();
11976 return resultobj;
11977fail:
11978 return NULL;
11979}
11980
11981
11982SWIGINTERN PyObject *_wrap_plsfnam(PyObject *self, PyObject *args) {
11983 PyObject *resultobj = 0;
11984 char *arg1 = (char *) 0 ;
11985 int res1 ;
11986 char *buf1 = 0 ;
11987 int alloc1 = 0 ;
11988 PyObject *swig_obj[1] ;
11989
11990 (void)self;
11991 if (!args) SWIG_fail;
11992 swig_obj[0] = args;
11993 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
11994 if (!SWIG_IsOK(res1)) {
11995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
11996 }
11997 arg1 = (char *)(buf1);
11998 plsfnam((char const *)arg1);
11999 resultobj = SWIG_Py_Void();
12000 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12001 return resultobj;
12002fail:
12003 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12004 return NULL;
12005}
12006
12007
12008SWIGINTERN PyObject *_wrap_plsfont(PyObject *self, PyObject *args) {
12009 PyObject *resultobj = 0;
12010 PLINT arg1 ;
12011 PLINT arg2 ;
12012 PLINT arg3 ;
12013 int val1 ;
12014 int ecode1 = 0 ;
12015 int val2 ;
12016 int ecode2 = 0 ;
12017 int val3 ;
12018 int ecode3 = 0 ;
12019 PyObject *swig_obj[3] ;
12020
12021 (void)self;
12022 if (!SWIG_Python_UnpackTuple(args, "plsfont", 3, 3, swig_obj)) SWIG_fail;
12023 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12024 if (!SWIG_IsOK(ecode1)) {
12025 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
12026 }
12027 arg1 = (PLINT)(val1);
12028 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12029 if (!SWIG_IsOK(ecode2)) {
12030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
12031 }
12032 arg2 = (PLINT)(val2);
12033 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12034 if (!SWIG_IsOK(ecode3)) {
12035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
12036 }
12037 arg3 = (PLINT)(val3);
12038 plsfont(arg1,arg2,arg3);
12039 resultobj = SWIG_Py_Void();
12040 return resultobj;
12041fail:
12042 return NULL;
12043}
12044
12045
12046SWIGINTERN PyObject *_wrap_plshades(PyObject *self, PyObject *args) {
12047 PyObject *resultobj = 0;
12048 PLFLT **arg1 = (PLFLT **) 0 ;
12049 PLINT arg2 ;
12050 PLINT arg3 ;
12051 defined_func arg4 = (defined_func) 0 ;
12052 PLFLT arg5 ;
12053 PLFLT arg6 ;
12054 PLFLT arg7 ;
12055 PLFLT arg8 ;
12056 PLFLT *arg9 = (PLFLT *) 0 ;
12057 PLINT arg10 ;
12058 PLFLT arg11 ;
12059 PLINT arg12 ;
12060 PLFLT arg13 ;
12061 fill_func arg14 = (fill_func) 0 ;
12062 PLBOOL arg15 ;
12063 pltr_func arg16 = (pltr_func) 0 ;
12064 PLPointer arg17 = (PLPointer) 0 ;
12065 PyArrayObject *tmp1 = NULL ;
12066 double val5 ;
12067 int ecode5 = 0 ;
12068 double val6 ;
12069 int ecode6 = 0 ;
12070 double val7 ;
12071 int ecode7 = 0 ;
12072 double val8 ;
12073 int ecode8 = 0 ;
12074 PyArrayObject *tmp9 = NULL ;
12075 double val11 ;
12076 int ecode11 = 0 ;
12077 int val12 ;
12078 int ecode12 = 0 ;
12079 double val13 ;
12080 int ecode13 = 0 ;
12081 int val15 ;
12082 int ecode15 = 0 ;
12083 PyObject *swig_obj[12] ;
12084
12085 {
12086 python_pltr = 0;
12087 arg16 = NULL;
12088 }
12089 {
12090 arg17 = NULL;
12091 }
12092 {
12093 arg4 = NULL;
12094 }
12095 {
12096 arg14 = plfill;
12097 }
12098 (void)self;
12099 if (!SWIG_Python_UnpackTuple(args, "plshades", 10, 12, swig_obj)) SWIG_fail;
12100 {
12101 int i, size;
12102 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12103 if ( tmp1 == NULL )
12104 return NULL;
12105 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12106 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12107 size = arg3;
12108 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12109 for ( i = 0; i < arg2; i++ )
12110 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12111 }
12112 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12113 if (!SWIG_IsOK(ecode5)) {
12114 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
12115 }
12116 arg5 = (PLFLT)(val5);
12117 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12118 if (!SWIG_IsOK(ecode6)) {
12119 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
12120 }
12121 arg6 = (PLFLT)(val6);
12122 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12123 if (!SWIG_IsOK(ecode7)) {
12124 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
12125 }
12126 arg7 = (PLFLT)(val7);
12127 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12128 if (!SWIG_IsOK(ecode8)) {
12129 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshades" "', argument " "8"" of type '" "PLFLT""'");
12130 }
12131 arg8 = (PLFLT)(val8);
12132 {
12133 tmp9 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[5], NPY_PLFLT, 1, 1 );
12134 if ( tmp9 == NULL )
12135 return NULL;
12136 arg10 = PyArray_DIMS( tmp9 )[0];
12137 arg9 = (PLFLT *) PyArray_DATA( tmp9 );
12138 }
12139 ecode11 = SWIG_AsVal_double(swig_obj[6], &val11);
12140 if (!SWIG_IsOK(ecode11)) {
12141 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLFLT""'");
12142 }
12143 arg11 = (PLFLT)(val11);
12144 ecode12 = SWIG_AsVal_int(swig_obj[7], &val12);
12145 if (!SWIG_IsOK(ecode12)) {
12146 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
12147 }
12148 arg12 = (PLINT)(val12);
12149 ecode13 = SWIG_AsVal_double(swig_obj[8], &val13);
12150 if (!SWIG_IsOK(ecode13)) {
12151 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLFLT""'");
12152 }
12153 arg13 = (PLFLT)(val13);
12154 ecode15 = SWIG_AsVal_int(swig_obj[9], &val15);
12155 if (!SWIG_IsOK(ecode15)) {
12156 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshades" "', argument " "15"" of type '" "PLBOOL""'");
12157 }
12158 arg15 = (PLBOOL)(val15);
12159 if (swig_obj[10]) {
12160 {
12161 // it must be a callable or None
12162 if ( swig_obj[10] == Py_None )
12163 {
12164 arg16 = NULL;
12165 }
12166 else
12167 {
12168 if ( !PyCallable_Check( (PyObject *) swig_obj[10] ) )
12169 {
12170 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12171 return NULL;
12172 }
12173 arg16 = marshal_pltr( swig_obj[10] );
12174 }
12175 }
12176 }
12177 if (swig_obj[11]) {
12178 {
12179 if ( swig_obj[11] == Py_None )
12180 arg17 = NULL;
12181 else
12182 {
12183 arg17 = marshal_PLPointer( swig_obj[11], 0 );
12184 }
12185 }
12186 }
12187 plshades((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(double const *)arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
12188 resultobj = SWIG_Py_Void();
12189 {
12190 Py_CLEAR( tmp1 );
12191 free( arg1 );
12192 }
12193 {
12194 Py_CLEAR( tmp9 );
12195 }
12196 {
12197 cleanup_pltr();
12198 }
12199 {
12201 }
12202 return resultobj;
12203fail:
12204 {
12205 Py_CLEAR( tmp1 );
12206 free( arg1 );
12207 }
12208 {
12209 Py_CLEAR( tmp9 );
12210 }
12211 {
12212 cleanup_pltr();
12213 }
12214 {
12216 }
12217 return NULL;
12218}
12219
12220
12221SWIGINTERN PyObject *_wrap_plshade(PyObject *self, PyObject *args) {
12222 PyObject *resultobj = 0;
12223 PLFLT **arg1 = (PLFLT **) 0 ;
12224 PLINT arg2 ;
12225 PLINT arg3 ;
12226 defined_func arg4 = (defined_func) 0 ;
12227 PLFLT arg5 ;
12228 PLFLT arg6 ;
12229 PLFLT arg7 ;
12230 PLFLT arg8 ;
12231 PLFLT arg9 ;
12232 PLFLT arg10 ;
12233 PLINT arg11 ;
12234 PLFLT arg12 ;
12235 PLFLT arg13 ;
12236 PLINT arg14 ;
12237 PLFLT arg15 ;
12238 PLINT arg16 ;
12239 PLFLT arg17 ;
12240 fill_func arg18 = (fill_func) 0 ;
12241 PLBOOL arg19 ;
12242 pltr_func arg20 = (pltr_func) 0 ;
12243 PLPointer arg21 = (PLPointer) 0 ;
12244 PyArrayObject *tmp1 = NULL ;
12245 double val5 ;
12246 int ecode5 = 0 ;
12247 double val6 ;
12248 int ecode6 = 0 ;
12249 double val7 ;
12250 int ecode7 = 0 ;
12251 double val8 ;
12252 int ecode8 = 0 ;
12253 double val9 ;
12254 int ecode9 = 0 ;
12255 double val10 ;
12256 int ecode10 = 0 ;
12257 int val11 ;
12258 int ecode11 = 0 ;
12259 double val12 ;
12260 int ecode12 = 0 ;
12261 double val13 ;
12262 int ecode13 = 0 ;
12263 int val14 ;
12264 int ecode14 = 0 ;
12265 double val15 ;
12266 int ecode15 = 0 ;
12267 int val16 ;
12268 int ecode16 = 0 ;
12269 double val17 ;
12270 int ecode17 = 0 ;
12271 int val19 ;
12272 int ecode19 = 0 ;
12273 PyObject *swig_obj[17] ;
12274
12275 {
12276 python_pltr = 0;
12277 arg20 = NULL;
12278 }
12279 {
12280 arg21 = NULL;
12281 }
12282 {
12283 arg4 = NULL;
12284 }
12285 {
12286 arg18 = plfill;
12287 }
12288 (void)self;
12289 if (!SWIG_Python_UnpackTuple(args, "plshade", 15, 17, swig_obj)) SWIG_fail;
12290 {
12291 int i, size;
12292 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
12293 if ( tmp1 == NULL )
12294 return NULL;
12295 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
12296 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
12297 size = arg3;
12298 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
12299 for ( i = 0; i < arg2; i++ )
12300 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
12301 }
12302 ecode5 = SWIG_AsVal_double(swig_obj[1], &val5);
12303 if (!SWIG_IsOK(ecode5)) {
12304 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12305 }
12306 arg5 = (PLFLT)(val5);
12307 ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
12308 if (!SWIG_IsOK(ecode6)) {
12309 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12310 }
12311 arg6 = (PLFLT)(val6);
12312 ecode7 = SWIG_AsVal_double(swig_obj[3], &val7);
12313 if (!SWIG_IsOK(ecode7)) {
12314 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12315 }
12316 arg7 = (PLFLT)(val7);
12317 ecode8 = SWIG_AsVal_double(swig_obj[4], &val8);
12318 if (!SWIG_IsOK(ecode8)) {
12319 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12320 }
12321 arg8 = (PLFLT)(val8);
12322 ecode9 = SWIG_AsVal_double(swig_obj[5], &val9);
12323 if (!SWIG_IsOK(ecode9)) {
12324 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12325 }
12326 arg9 = (PLFLT)(val9);
12327 ecode10 = SWIG_AsVal_double(swig_obj[6], &val10);
12328 if (!SWIG_IsOK(ecode10)) {
12329 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12330 }
12331 arg10 = (PLFLT)(val10);
12332 ecode11 = SWIG_AsVal_int(swig_obj[7], &val11);
12333 if (!SWIG_IsOK(ecode11)) {
12334 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12335 }
12336 arg11 = (PLINT)(val11);
12337 ecode12 = SWIG_AsVal_double(swig_obj[8], &val12);
12338 if (!SWIG_IsOK(ecode12)) {
12339 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
12340 }
12341 arg12 = (PLFLT)(val12);
12342 ecode13 = SWIG_AsVal_double(swig_obj[9], &val13);
12343 if (!SWIG_IsOK(ecode13)) {
12344 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLFLT""'");
12345 }
12346 arg13 = (PLFLT)(val13);
12347 ecode14 = SWIG_AsVal_int(swig_obj[10], &val14);
12348 if (!SWIG_IsOK(ecode14)) {
12349 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
12350 }
12351 arg14 = (PLINT)(val14);
12352 ecode15 = SWIG_AsVal_double(swig_obj[11], &val15);
12353 if (!SWIG_IsOK(ecode15)) {
12354 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLFLT""'");
12355 }
12356 arg15 = (PLFLT)(val15);
12357 ecode16 = SWIG_AsVal_int(swig_obj[12], &val16);
12358 if (!SWIG_IsOK(ecode16)) {
12359 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
12360 }
12361 arg16 = (PLINT)(val16);
12362 ecode17 = SWIG_AsVal_double(swig_obj[13], &val17);
12363 if (!SWIG_IsOK(ecode17)) {
12364 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLFLT""'");
12365 }
12366 arg17 = (PLFLT)(val17);
12367 ecode19 = SWIG_AsVal_int(swig_obj[14], &val19);
12368 if (!SWIG_IsOK(ecode19)) {
12369 SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "plshade" "', argument " "19"" of type '" "PLBOOL""'");
12370 }
12371 arg19 = (PLBOOL)(val19);
12372 if (swig_obj[15]) {
12373 {
12374 // it must be a callable or None
12375 if ( swig_obj[15] == Py_None )
12376 {
12377 arg20 = NULL;
12378 }
12379 else
12380 {
12381 if ( !PyCallable_Check( (PyObject *) swig_obj[15] ) )
12382 {
12383 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
12384 return NULL;
12385 }
12386 arg20 = marshal_pltr( swig_obj[15] );
12387 }
12388 }
12389 }
12390 if (swig_obj[16]) {
12391 {
12392 if ( swig_obj[16] == Py_None )
12393 arg21 = NULL;
12394 else
12395 {
12396 arg21 = marshal_PLPointer( swig_obj[16], 0 );
12397 }
12398 }
12399 }
12400 plshade((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
12401 resultobj = SWIG_Py_Void();
12402 {
12403 Py_CLEAR( tmp1 );
12404 free( arg1 );
12405 }
12406 {
12407 cleanup_pltr();
12408 }
12409 {
12411 }
12412 return resultobj;
12413fail:
12414 {
12415 Py_CLEAR( tmp1 );
12416 free( arg1 );
12417 }
12418 {
12419 cleanup_pltr();
12420 }
12421 {
12423 }
12424 return NULL;
12425}
12426
12427
12428SWIGINTERN PyObject *_wrap_plslabelfunc(PyObject *self, PyObject *args) {
12429 PyObject *resultobj = 0;
12430 label_func arg1 = (label_func) 0 ;
12431 PLPointer arg2 = (PLPointer) 0 ;
12432 int res2 ;
12433 PyObject *swig_obj[2] ;
12434
12435 (void)self;
12436 if (!SWIG_Python_UnpackTuple(args, "plslabelfunc", 2, 2, swig_obj)) SWIG_fail;
12437 {
12438 // Release reference to previous function if applicable
12439 if ( python_label )
12440 {
12441 Py_CLEAR( python_label );
12442 python_label = 0;
12443 }
12444 // it must be a callable or None
12445 if ( swig_obj[0] == Py_None )
12446 {
12447 arg1 = NULL;
12448 }
12449 else
12450 {
12451 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
12452 {
12453 PyErr_SetString( PyExc_ValueError, "label_func argument must be callable" );
12454 return NULL;
12455 }
12456 // hold a reference to it
12457 Py_XINCREF( (PyObject *) swig_obj[0] );
12458 python_label = (PyObject *) swig_obj[0];
12459 // this function handles calling the python function
12460 arg1 = do_label_callback;
12461 }
12462 }
12463 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
12464 if (!SWIG_IsOK(res2)) {
12465 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
12466 }
12467 plslabelfunc(arg1,arg2);
12468 resultobj = SWIG_Py_Void();
12469 return resultobj;
12470fail:
12471 return NULL;
12472}
12473
12474
12475SWIGINTERN PyObject *_wrap_plsmaj(PyObject *self, PyObject *args) {
12476 PyObject *resultobj = 0;
12477 PLFLT arg1 ;
12478 PLFLT arg2 ;
12479 double val1 ;
12480 int ecode1 = 0 ;
12481 double val2 ;
12482 int ecode2 = 0 ;
12483 PyObject *swig_obj[2] ;
12484
12485 (void)self;
12486 if (!SWIG_Python_UnpackTuple(args, "plsmaj", 2, 2, swig_obj)) SWIG_fail;
12487 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12488 if (!SWIG_IsOK(ecode1)) {
12489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
12490 }
12491 arg1 = (PLFLT)(val1);
12492 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12493 if (!SWIG_IsOK(ecode2)) {
12494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
12495 }
12496 arg2 = (PLFLT)(val2);
12497 plsmaj(arg1,arg2);
12498 resultobj = SWIG_Py_Void();
12499 return resultobj;
12500fail:
12501 return NULL;
12502}
12503
12504
12505SWIGINTERN PyObject *_wrap_plsmem(PyObject *self, PyObject *args) {
12506 PyObject *resultobj = 0;
12507 PLINT arg1 ;
12508 PLINT arg2 ;
12509 void *arg3 = (void *) 0 ;
12510 int val1 ;
12511 int ecode1 = 0 ;
12512 int val2 ;
12513 int ecode2 = 0 ;
12514 PyObject *swig_obj[3] ;
12515
12516 (void)self;
12517 if (!SWIG_Python_UnpackTuple(args, "plsmem", 3, 3, swig_obj)) SWIG_fail;
12518 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12519 if (!SWIG_IsOK(ecode1)) {
12520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmem" "', argument " "1"" of type '" "PLINT""'");
12521 }
12522 arg1 = (PLINT)(val1);
12523 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12524 if (!SWIG_IsOK(ecode2)) {
12525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmem" "', argument " "2"" of type '" "PLINT""'");
12526 }
12527 arg2 = (PLINT)(val2);
12528 {
12529 int res; void *buf = 0;
12530#ifndef Py_LIMITED_API
12531 Py_buffer view;
12532 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12533#else
12534#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12535#pragma GCC diagnostic push
12536#pragma GCC diagnostic ignored "-Wdeprecated"
12537#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12538#elif defined(_MSC_VER)
12539#pragma warning(push)
12540#pragma warning(disable: 4996)
12541#endif
12542 Py_ssize_t size;
12543 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12544#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12545#pragma GCC diagnostic pop
12546#elif defined(_MSC_VER)
12547#pragma warning(pop)
12548#endif
12549#endif
12550 if (res < 0) {
12551 PyErr_Clear();
12552 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmem" "', argument " "3"" of type '" "(void * plotmem)""'");
12553 }
12554#ifndef Py_LIMITED_API
12555 buf = view.buf;
12556 PyBuffer_Release(&view);
12557#endif
12558 arg3 = (void *) buf;
12559 }
12560 plsmem(arg1,arg2,arg3);
12561 resultobj = SWIG_Py_Void();
12562 return resultobj;
12563fail:
12564 return NULL;
12565}
12566
12567
12568SWIGINTERN PyObject *_wrap_plsmema(PyObject *self, PyObject *args) {
12569 PyObject *resultobj = 0;
12570 PLINT arg1 ;
12571 PLINT arg2 ;
12572 void *arg3 = (void *) 0 ;
12573 int val1 ;
12574 int ecode1 = 0 ;
12575 int val2 ;
12576 int ecode2 = 0 ;
12577 PyObject *swig_obj[3] ;
12578
12579 (void)self;
12580 if (!SWIG_Python_UnpackTuple(args, "plsmema", 3, 3, swig_obj)) SWIG_fail;
12581 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12582 if (!SWIG_IsOK(ecode1)) {
12583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmema" "', argument " "1"" of type '" "PLINT""'");
12584 }
12585 arg1 = (PLINT)(val1);
12586 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12587 if (!SWIG_IsOK(ecode2)) {
12588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmema" "', argument " "2"" of type '" "PLINT""'");
12589 }
12590 arg2 = (PLINT)(val2);
12591 {
12592 int res; void *buf = 0;
12593#ifndef Py_LIMITED_API
12594 Py_buffer view;
12595 res = PyObject_GetBuffer(swig_obj[2], &view, PyBUF_WRITABLE);
12596#else
12597#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12598#pragma GCC diagnostic push
12599#pragma GCC diagnostic ignored "-Wdeprecated"
12600#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
12601#elif defined(_MSC_VER)
12602#pragma warning(push)
12603#pragma warning(disable: 4996)
12604#endif
12605 Py_ssize_t size;
12606 res = PyObject_AsWriteBuffer(swig_obj[2], &buf, &size);
12607#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
12608#pragma GCC diagnostic pop
12609#elif defined(_MSC_VER)
12610#pragma warning(pop)
12611#endif
12612#endif
12613 if (res < 0) {
12614 PyErr_Clear();
12615 SWIG_exception_fail(SWIG_ArgError(res), "in method '" "plsmema" "', argument " "3"" of type '" "(void * plotmem)""'");
12616 }
12617#ifndef Py_LIMITED_API
12618 buf = view.buf;
12619 PyBuffer_Release(&view);
12620#endif
12621 arg3 = (void *) buf;
12622 }
12623 plsmema(arg1,arg2,arg3);
12624 resultobj = SWIG_Py_Void();
12625 return resultobj;
12626fail:
12627 return NULL;
12628}
12629
12630
12631SWIGINTERN PyObject *_wrap_plsmin(PyObject *self, PyObject *args) {
12632 PyObject *resultobj = 0;
12633 PLFLT arg1 ;
12634 PLFLT arg2 ;
12635 double val1 ;
12636 int ecode1 = 0 ;
12637 double val2 ;
12638 int ecode2 = 0 ;
12639 PyObject *swig_obj[2] ;
12640
12641 (void)self;
12642 if (!SWIG_Python_UnpackTuple(args, "plsmin", 2, 2, swig_obj)) SWIG_fail;
12643 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12644 if (!SWIG_IsOK(ecode1)) {
12645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
12646 }
12647 arg1 = (PLFLT)(val1);
12648 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12649 if (!SWIG_IsOK(ecode2)) {
12650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
12651 }
12652 arg2 = (PLFLT)(val2);
12653 plsmin(arg1,arg2);
12654 resultobj = SWIG_Py_Void();
12655 return resultobj;
12656fail:
12657 return NULL;
12658}
12659
12660
12661SWIGINTERN PyObject *_wrap_plsori(PyObject *self, PyObject *args) {
12662 PyObject *resultobj = 0;
12663 PLINT arg1 ;
12664 int val1 ;
12665 int ecode1 = 0 ;
12666 PyObject *swig_obj[1] ;
12667
12668 (void)self;
12669 if (!args) SWIG_fail;
12670 swig_obj[0] = args;
12671 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12672 if (!SWIG_IsOK(ecode1)) {
12673 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
12674 }
12675 arg1 = (PLINT)(val1);
12676 plsori(arg1);
12677 resultobj = SWIG_Py_Void();
12678 return resultobj;
12679fail:
12680 return NULL;
12681}
12682
12683
12684SWIGINTERN PyObject *_wrap_plspage(PyObject *self, PyObject *args) {
12685 PyObject *resultobj = 0;
12686 PLFLT arg1 ;
12687 PLFLT arg2 ;
12688 PLINT arg3 ;
12689 PLINT arg4 ;
12690 PLINT arg5 ;
12691 PLINT arg6 ;
12692 double val1 ;
12693 int ecode1 = 0 ;
12694 double val2 ;
12695 int ecode2 = 0 ;
12696 int val3 ;
12697 int ecode3 = 0 ;
12698 int val4 ;
12699 int ecode4 = 0 ;
12700 int val5 ;
12701 int ecode5 = 0 ;
12702 int val6 ;
12703 int ecode6 = 0 ;
12704 PyObject *swig_obj[6] ;
12705
12706 (void)self;
12707 if (!SWIG_Python_UnpackTuple(args, "plspage", 6, 6, swig_obj)) SWIG_fail;
12708 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12709 if (!SWIG_IsOK(ecode1)) {
12710 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
12711 }
12712 arg1 = (PLFLT)(val1);
12713 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12714 if (!SWIG_IsOK(ecode2)) {
12715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
12716 }
12717 arg2 = (PLFLT)(val2);
12718 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12719 if (!SWIG_IsOK(ecode3)) {
12720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
12721 }
12722 arg3 = (PLINT)(val3);
12723 ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
12724 if (!SWIG_IsOK(ecode4)) {
12725 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
12726 }
12727 arg4 = (PLINT)(val4);
12728 ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
12729 if (!SWIG_IsOK(ecode5)) {
12730 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
12731 }
12732 arg5 = (PLINT)(val5);
12733 ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
12734 if (!SWIG_IsOK(ecode6)) {
12735 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
12736 }
12737 arg6 = (PLINT)(val6);
12738 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
12739 resultobj = SWIG_Py_Void();
12740 return resultobj;
12741fail:
12742 return NULL;
12743}
12744
12745
12746SWIGINTERN PyObject *_wrap_plspal0(PyObject *self, PyObject *args) {
12747 PyObject *resultobj = 0;
12748 char *arg1 = (char *) 0 ;
12749 int res1 ;
12750 char *buf1 = 0 ;
12751 int alloc1 = 0 ;
12752 PyObject *swig_obj[1] ;
12753
12754 (void)self;
12755 if (!args) SWIG_fail;
12756 swig_obj[0] = args;
12757 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12758 if (!SWIG_IsOK(res1)) {
12759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
12760 }
12761 arg1 = (char *)(buf1);
12762 plspal0((char const *)arg1);
12763 resultobj = SWIG_Py_Void();
12764 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12765 return resultobj;
12766fail:
12767 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12768 return NULL;
12769}
12770
12771
12772SWIGINTERN PyObject *_wrap_plspal1(PyObject *self, PyObject *args) {
12773 PyObject *resultobj = 0;
12774 char *arg1 = (char *) 0 ;
12775 PLBOOL arg2 ;
12776 int res1 ;
12777 char *buf1 = 0 ;
12778 int alloc1 = 0 ;
12779 int val2 ;
12780 int ecode2 = 0 ;
12781 PyObject *swig_obj[2] ;
12782
12783 (void)self;
12784 if (!SWIG_Python_UnpackTuple(args, "plspal1", 2, 2, swig_obj)) SWIG_fail;
12785 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12786 if (!SWIG_IsOK(res1)) {
12787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
12788 }
12789 arg1 = (char *)(buf1);
12790 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12791 if (!SWIG_IsOK(ecode2)) {
12792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
12793 }
12794 arg2 = (PLBOOL)(val2);
12795 plspal1((char const *)arg1,arg2);
12796 resultobj = SWIG_Py_Void();
12797 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12798 return resultobj;
12799fail:
12800 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12801 return NULL;
12802}
12803
12804
12805SWIGINTERN PyObject *_wrap_plspause(PyObject *self, PyObject *args) {
12806 PyObject *resultobj = 0;
12807 PLBOOL arg1 ;
12808 int val1 ;
12809 int ecode1 = 0 ;
12810 PyObject *swig_obj[1] ;
12811
12812 (void)self;
12813 if (!args) SWIG_fail;
12814 swig_obj[0] = args;
12815 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12816 if (!SWIG_IsOK(ecode1)) {
12817 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
12818 }
12819 arg1 = (PLBOOL)(val1);
12820 plspause(arg1);
12821 resultobj = SWIG_Py_Void();
12822 return resultobj;
12823fail:
12824 return NULL;
12825}
12826
12827
12828SWIGINTERN PyObject *_wrap_plsstrm(PyObject *self, PyObject *args) {
12829 PyObject *resultobj = 0;
12830 PLINT arg1 ;
12831 int val1 ;
12832 int ecode1 = 0 ;
12833 PyObject *swig_obj[1] ;
12834
12835 (void)self;
12836 if (!args) SWIG_fail;
12837 swig_obj[0] = args;
12838 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12839 if (!SWIG_IsOK(ecode1)) {
12840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
12841 }
12842 arg1 = (PLINT)(val1);
12843 plsstrm(arg1);
12844 resultobj = SWIG_Py_Void();
12845 return resultobj;
12846fail:
12847 return NULL;
12848}
12849
12850
12851SWIGINTERN PyObject *_wrap_plssub(PyObject *self, PyObject *args) {
12852 PyObject *resultobj = 0;
12853 PLINT arg1 ;
12854 PLINT arg2 ;
12855 int val1 ;
12856 int ecode1 = 0 ;
12857 int val2 ;
12858 int ecode2 = 0 ;
12859 PyObject *swig_obj[2] ;
12860
12861 (void)self;
12862 if (!SWIG_Python_UnpackTuple(args, "plssub", 2, 2, swig_obj)) SWIG_fail;
12863 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12864 if (!SWIG_IsOK(ecode1)) {
12865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
12866 }
12867 arg1 = (PLINT)(val1);
12868 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12869 if (!SWIG_IsOK(ecode2)) {
12870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
12871 }
12872 arg2 = (PLINT)(val2);
12873 plssub(arg1,arg2);
12874 resultobj = SWIG_Py_Void();
12875 return resultobj;
12876fail:
12877 return NULL;
12878}
12879
12880
12881SWIGINTERN PyObject *_wrap_plssym(PyObject *self, PyObject *args) {
12882 PyObject *resultobj = 0;
12883 PLFLT arg1 ;
12884 PLFLT arg2 ;
12885 double val1 ;
12886 int ecode1 = 0 ;
12887 double val2 ;
12888 int ecode2 = 0 ;
12889 PyObject *swig_obj[2] ;
12890
12891 (void)self;
12892 if (!SWIG_Python_UnpackTuple(args, "plssym", 2, 2, swig_obj)) SWIG_fail;
12893 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
12894 if (!SWIG_IsOK(ecode1)) {
12895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
12896 }
12897 arg1 = (PLFLT)(val1);
12898 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12899 if (!SWIG_IsOK(ecode2)) {
12900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
12901 }
12902 arg2 = (PLFLT)(val2);
12903 plssym(arg1,arg2);
12904 resultobj = SWIG_Py_Void();
12905 return resultobj;
12906fail:
12907 return NULL;
12908}
12909
12910
12911SWIGINTERN PyObject *_wrap_plstar(PyObject *self, PyObject *args) {
12912 PyObject *resultobj = 0;
12913 PLINT arg1 ;
12914 PLINT arg2 ;
12915 int val1 ;
12916 int ecode1 = 0 ;
12917 int val2 ;
12918 int ecode2 = 0 ;
12919 PyObject *swig_obj[2] ;
12920
12921 (void)self;
12922 if (!SWIG_Python_UnpackTuple(args, "plstar", 2, 2, swig_obj)) SWIG_fail;
12923 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
12924 if (!SWIG_IsOK(ecode1)) {
12925 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
12926 }
12927 arg1 = (PLINT)(val1);
12928 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12929 if (!SWIG_IsOK(ecode2)) {
12930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
12931 }
12932 arg2 = (PLINT)(val2);
12933 plstar(arg1,arg2);
12934 resultobj = SWIG_Py_Void();
12935 return resultobj;
12936fail:
12937 return NULL;
12938}
12939
12940
12941SWIGINTERN PyObject *_wrap_plstart(PyObject *self, PyObject *args) {
12942 PyObject *resultobj = 0;
12943 char *arg1 = (char *) 0 ;
12944 PLINT arg2 ;
12945 PLINT arg3 ;
12946 int res1 ;
12947 char *buf1 = 0 ;
12948 int alloc1 = 0 ;
12949 int val2 ;
12950 int ecode2 = 0 ;
12951 int val3 ;
12952 int ecode3 = 0 ;
12953 PyObject *swig_obj[3] ;
12954
12955 (void)self;
12956 if (!SWIG_Python_UnpackTuple(args, "plstart", 3, 3, swig_obj)) SWIG_fail;
12957 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
12958 if (!SWIG_IsOK(res1)) {
12959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
12960 }
12961 arg1 = (char *)(buf1);
12962 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12963 if (!SWIG_IsOK(ecode2)) {
12964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
12965 }
12966 arg2 = (PLINT)(val2);
12967 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
12968 if (!SWIG_IsOK(ecode3)) {
12969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
12970 }
12971 arg3 = (PLINT)(val3);
12972 plstart((char const *)arg1,arg2,arg3);
12973 resultobj = SWIG_Py_Void();
12974 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12975 return resultobj;
12976fail:
12977 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
12978 return NULL;
12979}
12980
12981
12982SWIGINTERN PyObject *_wrap_plstransform(PyObject *self, PyObject *args) {
12983 PyObject *resultobj = 0;
12984 ct_func arg1 = (ct_func) 0 ;
12985 PLPointer arg2 = (PLPointer) 0 ;
12986 int res2 ;
12987 PyObject *swig_obj[2] ;
12988
12989 {
12990 python_ct = 0;
12991 arg1 = NULL;
12992 }
12993 (void)self;
12994 if (!SWIG_Python_UnpackTuple(args, "plstransform", 0, 2, swig_obj)) SWIG_fail;
12995 if (swig_obj[0]) {
12996 {
12997 if ( python_ct )
12998 cleanup_ct();
12999 // it must be a callable or none
13000 if ( swig_obj[0] == Py_None )
13001 {
13002 arg1 = NULL;
13003 }
13004 else
13005 {
13006 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
13007 {
13008 PyErr_SetString( PyExc_ValueError, "coordinate transform argument must be callable" );
13009 return NULL;
13010 }
13011 arg1 = marshal_ct( swig_obj[0] );
13012 }
13013 }
13014 }
13015 if (swig_obj[1]) {
13016 res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
13017 if (!SWIG_IsOK(res2)) {
13018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
13019 }
13020 }
13021 plstransform(arg1,arg2);
13022 resultobj = SWIG_Py_Void();
13023 return resultobj;
13024fail:
13025 return NULL;
13026}
13027
13028
13029SWIGINTERN PyObject *_wrap_plstring(PyObject *self, PyObject *args) {
13030 PyObject *resultobj = 0;
13031 PLINT arg1 ;
13032 PLFLT *arg2 = (PLFLT *) 0 ;
13033 PLFLT *arg3 = (PLFLT *) 0 ;
13034 char *arg4 = (char *) 0 ;
13035 PyArrayObject *tmp1 = NULL ;
13036 PyArrayObject *tmp3 = NULL ;
13037 int res4 ;
13038 char *buf4 = 0 ;
13039 int alloc4 = 0 ;
13040 PyObject *swig_obj[3] ;
13041
13042 (void)self;
13043 if (!SWIG_Python_UnpackTuple(args, "plstring", 3, 3, swig_obj)) SWIG_fail;
13044 {
13045 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13046 if ( tmp1 == NULL )
13047 return NULL;
13048 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13049 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13050 }
13051 {
13052 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13053 if ( tmp3 == NULL )
13054 return NULL;
13055 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13056 {
13057 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13058 return NULL;
13059 }
13060 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13061 }
13062 res4 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf4, NULL, &alloc4);
13063 if (!SWIG_IsOK(res4)) {
13064 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
13065 }
13066 arg4 = (char *)(buf4);
13067 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
13068 resultobj = SWIG_Py_Void();
13069 {
13070 Py_CLEAR( tmp1 );
13071 }
13072 {
13073 Py_CLEAR( tmp3 );
13074 }
13075 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13076 return resultobj;
13077fail:
13078 {
13079 Py_CLEAR( tmp1 );
13080 }
13081 {
13082 Py_CLEAR( tmp3 );
13083 }
13084 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
13085 return NULL;
13086}
13087
13088
13089SWIGINTERN PyObject *_wrap_plstring3(PyObject *self, PyObject *args) {
13090 PyObject *resultobj = 0;
13091 PLINT arg1 ;
13092 PLFLT *arg2 = (PLFLT *) 0 ;
13093 PLFLT *arg3 = (PLFLT *) 0 ;
13094 PLFLT *arg4 = (PLFLT *) 0 ;
13095 char *arg5 = (char *) 0 ;
13096 PyArrayObject *tmp1 = NULL ;
13097 PyArrayObject *tmp3 = NULL ;
13098 PyArrayObject *tmp4 = NULL ;
13099 int res5 ;
13100 char *buf5 = 0 ;
13101 int alloc5 = 0 ;
13102 PyObject *swig_obj[4] ;
13103
13104 (void)self;
13105 if (!SWIG_Python_UnpackTuple(args, "plstring3", 4, 4, swig_obj)) SWIG_fail;
13106 {
13107 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13108 if ( tmp1 == NULL )
13109 return NULL;
13110 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13111 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13112 }
13113 {
13114 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13115 if ( tmp3 == NULL )
13116 return NULL;
13117 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13118 {
13119 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13120 return NULL;
13121 }
13122 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13123 }
13124 {
13125 tmp4 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[2], NPY_PLFLT, 1, 1 );
13126 if ( tmp4 == NULL )
13127 return NULL;
13128 if ( PyArray_DIMS( tmp4 )[0] != Alen )
13129 {
13130 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13131 return NULL;
13132 }
13133 arg4 = (PLFLT *) PyArray_DATA( tmp4 );
13134 }
13135 res5 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf5, NULL, &alloc5);
13136 if (!SWIG_IsOK(res5)) {
13137 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
13138 }
13139 arg5 = (char *)(buf5);
13140 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
13141 resultobj = SWIG_Py_Void();
13142 {
13143 Py_CLEAR( tmp1 );
13144 }
13145 {
13146 Py_CLEAR( tmp3 );
13147 }
13148 {
13149 Py_CLEAR( tmp4 );
13150 }
13151 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13152 return resultobj;
13153fail:
13154 {
13155 Py_CLEAR( tmp1 );
13156 }
13157 {
13158 Py_CLEAR( tmp3 );
13159 }
13160 {
13161 Py_CLEAR( tmp4 );
13162 }
13163 if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
13164 return NULL;
13165}
13166
13167
13168SWIGINTERN PyObject *_wrap_plstripa(PyObject *self, PyObject *args) {
13169 PyObject *resultobj = 0;
13170 PLINT arg1 ;
13171 PLINT arg2 ;
13172 PLFLT arg3 ;
13173 PLFLT arg4 ;
13174 int val1 ;
13175 int ecode1 = 0 ;
13176 int val2 ;
13177 int ecode2 = 0 ;
13178 double val3 ;
13179 int ecode3 = 0 ;
13180 double val4 ;
13181 int ecode4 = 0 ;
13182 PyObject *swig_obj[4] ;
13183
13184 (void)self;
13185 if (!SWIG_Python_UnpackTuple(args, "plstripa", 4, 4, swig_obj)) SWIG_fail;
13186 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13187 if (!SWIG_IsOK(ecode1)) {
13188 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
13189 }
13190 arg1 = (PLINT)(val1);
13191 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13192 if (!SWIG_IsOK(ecode2)) {
13193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
13194 }
13195 arg2 = (PLINT)(val2);
13196 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13197 if (!SWIG_IsOK(ecode3)) {
13198 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
13199 }
13200 arg3 = (PLFLT)(val3);
13201 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13202 if (!SWIG_IsOK(ecode4)) {
13203 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
13204 }
13205 arg4 = (PLFLT)(val4);
13206 plstripa(arg1,arg2,arg3,arg4);
13207 resultobj = SWIG_Py_Void();
13208 return resultobj;
13209fail:
13210 return NULL;
13211}
13212
13213
13214SWIGINTERN PyObject *_wrap_plstripc(PyObject *self, PyObject *args) {
13215 PyObject *resultobj = 0;
13216 PLINT *arg1 = (PLINT *) 0 ;
13217 char *arg2 = (char *) 0 ;
13218 char *arg3 = (char *) 0 ;
13219 PLFLT arg4 ;
13220 PLFLT arg5 ;
13221 PLFLT arg6 ;
13222 PLFLT arg7 ;
13223 PLFLT arg8 ;
13224 PLFLT arg9 ;
13225 PLFLT arg10 ;
13226 PLBOOL arg11 ;
13227 PLBOOL arg12 ;
13228 PLINT arg13 ;
13229 PLINT arg14 ;
13230 PLINT *arg15 = (PLINT *) 0 ;
13231 PLINT *arg16 = (PLINT *) 0 ;
13232 char **arg17 = (char **) (char **)0 ;
13233 char *arg18 = (char *) 0 ;
13234 char *arg19 = (char *) 0 ;
13235 char *arg20 = (char *) 0 ;
13236 PLINT temp1 ;
13237 int res1 = SWIG_TMPOBJ ;
13238 int res2 ;
13239 char *buf2 = 0 ;
13240 int alloc2 = 0 ;
13241 int res3 ;
13242 char *buf3 = 0 ;
13243 int alloc3 = 0 ;
13244 double val4 ;
13245 int ecode4 = 0 ;
13246 double val5 ;
13247 int ecode5 = 0 ;
13248 double val6 ;
13249 int ecode6 = 0 ;
13250 double val7 ;
13251 int ecode7 = 0 ;
13252 double val8 ;
13253 int ecode8 = 0 ;
13254 double val9 ;
13255 int ecode9 = 0 ;
13256 double val10 ;
13257 int ecode10 = 0 ;
13258 int val11 ;
13259 int ecode11 = 0 ;
13260 int val12 ;
13261 int ecode12 = 0 ;
13262 int val13 ;
13263 int ecode13 = 0 ;
13264 int val14 ;
13265 int ecode14 = 0 ;
13266 PyArrayObject *tmp15 = NULL ;
13267 PyArrayObject *tmp16 = NULL ;
13268 char **tmp17 = NULL ;
13269 int res18 ;
13270 char *buf18 = 0 ;
13271 int alloc18 = 0 ;
13272 int res19 ;
13273 char *buf19 = 0 ;
13274 int alloc19 = 0 ;
13275 int res20 ;
13276 char *buf20 = 0 ;
13277 int alloc20 = 0 ;
13278 PyObject *swig_obj[19] ;
13279
13280 arg1 = &temp1;
13281 (void)self;
13282 if (!SWIG_Python_UnpackTuple(args, "plstripc", 19, 19, swig_obj)) SWIG_fail;
13283 res2 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf2, NULL, &alloc2);
13284 if (!SWIG_IsOK(res2)) {
13285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
13286 }
13287 arg2 = (char *)(buf2);
13288 res3 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf3, NULL, &alloc3);
13289 if (!SWIG_IsOK(res3)) {
13290 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
13291 }
13292 arg3 = (char *)(buf3);
13293 ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
13294 if (!SWIG_IsOK(ecode4)) {
13295 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
13296 }
13297 arg4 = (PLFLT)(val4);
13298 ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
13299 if (!SWIG_IsOK(ecode5)) {
13300 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
13301 }
13302 arg5 = (PLFLT)(val5);
13303 ecode6 = SWIG_AsVal_double(swig_obj[4], &val6);
13304 if (!SWIG_IsOK(ecode6)) {
13305 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
13306 }
13307 arg6 = (PLFLT)(val6);
13308 ecode7 = SWIG_AsVal_double(swig_obj[5], &val7);
13309 if (!SWIG_IsOK(ecode7)) {
13310 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
13311 }
13312 arg7 = (PLFLT)(val7);
13313 ecode8 = SWIG_AsVal_double(swig_obj[6], &val8);
13314 if (!SWIG_IsOK(ecode8)) {
13315 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
13316 }
13317 arg8 = (PLFLT)(val8);
13318 ecode9 = SWIG_AsVal_double(swig_obj[7], &val9);
13319 if (!SWIG_IsOK(ecode9)) {
13320 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
13321 }
13322 arg9 = (PLFLT)(val9);
13323 ecode10 = SWIG_AsVal_double(swig_obj[8], &val10);
13324 if (!SWIG_IsOK(ecode10)) {
13325 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
13326 }
13327 arg10 = (PLFLT)(val10);
13328 ecode11 = SWIG_AsVal_int(swig_obj[9], &val11);
13329 if (!SWIG_IsOK(ecode11)) {
13330 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
13331 }
13332 arg11 = (PLBOOL)(val11);
13333 ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
13334 if (!SWIG_IsOK(ecode12)) {
13335 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
13336 }
13337 arg12 = (PLBOOL)(val12);
13338 ecode13 = SWIG_AsVal_int(swig_obj[11], &val13);
13339 if (!SWIG_IsOK(ecode13)) {
13340 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
13341 }
13342 arg13 = (PLINT)(val13);
13343 ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
13344 if (!SWIG_IsOK(ecode14)) {
13345 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
13346 }
13347 arg14 = (PLINT)(val14);
13348 {
13349 tmp15 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[13], NPY_PLINT, 1, 1 );
13350 if ( tmp15 == NULL )
13351 return NULL;
13352 Alen = PyArray_DIMS( tmp15 )[0];
13353 arg15 = (PLINT *) PyArray_DATA( tmp15 );
13354 }
13355 {
13356 tmp16 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[14], NPY_PLINT, 1, 1 );
13357 if ( tmp16 == NULL )
13358 return NULL;
13359 if ( PyArray_DIMS( tmp16 )[0] != Alen )
13360 {
13361 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13362 return NULL;
13363 }
13364 arg16 = (PLINT *) PyArray_DATA( tmp16 );
13365 }
13366 {
13367 int i;
13368 PyObject *elt, *unicode_string;
13369
13370 if ( !PySequence_Check( swig_obj[15] ) || PySequence_Size( swig_obj[15] ) != 4 )
13371 {
13372 PyErr_SetString( PyExc_ValueError, "Requires a sequence of 4 strings." );
13373 return NULL;
13374 }
13375 if ( Alen != 4 )
13376 {
13377 PyErr_SetString( PyExc_ValueError, "colline and styline args must be length 4." );
13378 return NULL;
13379 }
13380 tmp17 = (char **) malloc( sizeof ( char* ) * 4 );
13381 if ( tmp17 == NULL )
13382 return NULL;
13383 arg17 = tmp17;
13384 for ( i = 0; i < 4; i++ )
13385 {
13386 arg17[i] = NULL;
13387 elt = PySequence_Fast_GET_ITEM( swig_obj[15], i );
13388 if ( PyString_Check( elt ) )
13389 {
13390 arg17[i] = PyString_AsString( elt );
13391 }
13392 else if ( PyUnicode_Check( elt ) )
13393 {
13394 unicode_string = PyUnicode_AsEncodedString( elt, "utf-8", "Error ~" );
13395 arg17[i] = PyBytes_AS_STRING( unicode_string );
13396 }
13397 if ( arg17[i] == NULL )
13398 {
13399 free( tmp17 );
13400 return NULL;
13401 }
13402 }
13403 }
13404 res18 = SWIG_AsCharPtrAndSize(swig_obj[16], &buf18, NULL, &alloc18);
13405 if (!SWIG_IsOK(res18)) {
13406 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
13407 }
13408 arg18 = (char *)(buf18);
13409 res19 = SWIG_AsCharPtrAndSize(swig_obj[17], &buf19, NULL, &alloc19);
13410 if (!SWIG_IsOK(res19)) {
13411 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
13412 }
13413 arg19 = (char *)(buf19);
13414 res20 = SWIG_AsCharPtrAndSize(swig_obj[18], &buf20, NULL, &alloc20);
13415 if (!SWIG_IsOK(res20)) {
13416 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
13417 }
13418 arg20 = (char *)(buf20);
13419 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);
13420 resultobj = SWIG_Py_Void();
13421 if (SWIG_IsTmpObj(res1)) {
13422 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 1);
13423 } else {
13424 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 1);
13426 }
13427 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13428 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13429 {
13430 Py_CLEAR( tmp15 );
13431 }
13432 {
13433 Py_CLEAR( tmp16 );
13434 }
13435 {
13436 free( tmp17 );
13437 }
13438 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13439 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13440 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13441 return resultobj;
13442fail:
13443 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13444 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13445 {
13446 Py_CLEAR( tmp15 );
13447 }
13448 {
13449 Py_CLEAR( tmp16 );
13450 }
13451 {
13452 free( tmp17 );
13453 }
13454 if (alloc18 == SWIG_NEWOBJ) free((char*)buf18);
13455 if (alloc19 == SWIG_NEWOBJ) free((char*)buf19);
13456 if (alloc20 == SWIG_NEWOBJ) free((char*)buf20);
13457 return NULL;
13458}
13459
13460
13461SWIGINTERN PyObject *_wrap_plstripd(PyObject *self, PyObject *args) {
13462 PyObject *resultobj = 0;
13463 PLINT arg1 ;
13464 int val1 ;
13465 int ecode1 = 0 ;
13466 PyObject *swig_obj[1] ;
13467
13468 (void)self;
13469 if (!args) SWIG_fail;
13470 swig_obj[0] = args;
13471 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13472 if (!SWIG_IsOK(ecode1)) {
13473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
13474 }
13475 arg1 = (PLINT)(val1);
13476 plstripd(arg1);
13477 resultobj = SWIG_Py_Void();
13478 return resultobj;
13479fail:
13480 return NULL;
13481}
13482
13483
13484SWIGINTERN PyObject *_wrap_plstyl(PyObject *self, PyObject *args) {
13485 PyObject *resultobj = 0;
13486 PLINT arg1 ;
13487 PLINT *arg2 = (PLINT *) 0 ;
13488 PLINT *arg3 = (PLINT *) 0 ;
13489 PyArrayObject *tmp1 = NULL ;
13490 PyArrayObject *tmp3 = NULL ;
13491 PyObject *swig_obj[2] ;
13492
13493 (void)self;
13494 if (!SWIG_Python_UnpackTuple(args, "plstyl", 2, 2, swig_obj)) SWIG_fail;
13495 {
13496 tmp1 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[0], NPY_PLINT, 1, 1 );
13497 if ( tmp1 == NULL )
13498 return NULL;
13499 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13500 arg2 = (PLINT *) PyArray_DATA( tmp1 );
13501 }
13502 {
13503 tmp3 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[1], NPY_PLINT, 1, 1 );
13504 if ( tmp3 == NULL )
13505 return NULL;
13506 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13507 {
13508 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13509 return NULL;
13510 }
13511 arg3 = (PLINT *) PyArray_DATA( tmp3 );
13512 }
13513 plstyl(arg1,(int const *)arg2,(int const *)arg3);
13514 resultobj = SWIG_Py_Void();
13515 {
13516 Py_CLEAR( tmp1 );
13517 }
13518 {
13519 Py_CLEAR( tmp3 );
13520 }
13521 return resultobj;
13522fail:
13523 {
13524 Py_CLEAR( tmp1 );
13525 }
13526 {
13527 Py_CLEAR( tmp3 );
13528 }
13529 return NULL;
13530}
13531
13532
13533SWIGINTERN PyObject *_wrap_plsvect(PyObject *self, PyObject *args) {
13534 PyObject *resultobj = 0;
13535 PLFLT *arg1 = (PLFLT *) 0 ;
13536 PLFLT *arg2 = (PLFLT *) 0 ;
13537 PLINT arg3 ;
13538 PLBOOL arg4 ;
13539 PyArrayObject *tmp1 = NULL ;
13540 PyArrayObject *tmp2 = NULL ;
13541 int val4 ;
13542 int ecode4 = 0 ;
13543 PyObject *swig_obj[3] ;
13544
13545 (void)self;
13546 if (!SWIG_Python_UnpackTuple(args, "plsvect", 3, 3, swig_obj)) SWIG_fail;
13547 {
13548 if ( swig_obj[0] != Py_None )
13549 {
13550 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13551 if ( tmp1 == NULL )
13552 return NULL;
13553 Alen = PyArray_DIMS( tmp1 )[0];
13554 arg1 = (PLFLT *) PyArray_DATA( tmp1 );
13555 }
13556 else
13557 {
13558 arg1 = NULL;
13559 Alen = 0;
13560 }
13561 }
13562 {
13563 if ( swig_obj[1] != Py_None )
13564 {
13565 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13566 if ( tmp2 == NULL )
13567 return NULL;
13568 if ( PyArray_DIMS( tmp2 )[0] != Alen )
13569 {
13570 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13571 return NULL;
13572 }
13573 arg2 = (PLFLT *) PyArray_DATA( tmp2 );
13574 arg3 = PyArray_DIMS( tmp2 )[0];
13575 }
13576 else
13577 {
13578 arg2 = NULL;
13579 arg3 = 0;
13580 }
13581 }
13582 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13583 if (!SWIG_IsOK(ecode4)) {
13584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
13585 }
13586 arg4 = (PLBOOL)(val4);
13587 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
13588 resultobj = SWIG_Py_Void();
13589 {
13590 Py_CLEAR( tmp1 );
13591 }
13592 {
13593 Py_CLEAR( tmp2 );
13594 }
13595 return resultobj;
13596fail:
13597 {
13598 Py_CLEAR( tmp1 );
13599 }
13600 {
13601 Py_CLEAR( tmp2 );
13602 }
13603 return NULL;
13604}
13605
13606
13607SWIGINTERN PyObject *_wrap_plsvpa(PyObject *self, PyObject *args) {
13608 PyObject *resultobj = 0;
13609 PLFLT arg1 ;
13610 PLFLT arg2 ;
13611 PLFLT arg3 ;
13612 PLFLT arg4 ;
13613 double val1 ;
13614 int ecode1 = 0 ;
13615 double val2 ;
13616 int ecode2 = 0 ;
13617 double val3 ;
13618 int ecode3 = 0 ;
13619 double val4 ;
13620 int ecode4 = 0 ;
13621 PyObject *swig_obj[4] ;
13622
13623 (void)self;
13624 if (!SWIG_Python_UnpackTuple(args, "plsvpa", 4, 4, swig_obj)) SWIG_fail;
13625 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13626 if (!SWIG_IsOK(ecode1)) {
13627 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
13628 }
13629 arg1 = (PLFLT)(val1);
13630 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13631 if (!SWIG_IsOK(ecode2)) {
13632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
13633 }
13634 arg2 = (PLFLT)(val2);
13635 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
13636 if (!SWIG_IsOK(ecode3)) {
13637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
13638 }
13639 arg3 = (PLFLT)(val3);
13640 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
13641 if (!SWIG_IsOK(ecode4)) {
13642 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
13643 }
13644 arg4 = (PLFLT)(val4);
13645 plsvpa(arg1,arg2,arg3,arg4);
13646 resultobj = SWIG_Py_Void();
13647 return resultobj;
13648fail:
13649 return NULL;
13650}
13651
13652
13653SWIGINTERN PyObject *_wrap_plsxax(PyObject *self, PyObject *args) {
13654 PyObject *resultobj = 0;
13655 PLINT arg1 ;
13656 PLINT arg2 ;
13657 int val1 ;
13658 int ecode1 = 0 ;
13659 int val2 ;
13660 int ecode2 = 0 ;
13661 PyObject *swig_obj[2] ;
13662
13663 (void)self;
13664 if (!SWIG_Python_UnpackTuple(args, "plsxax", 2, 2, swig_obj)) SWIG_fail;
13665 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13666 if (!SWIG_IsOK(ecode1)) {
13667 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
13668 }
13669 arg1 = (PLINT)(val1);
13670 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13671 if (!SWIG_IsOK(ecode2)) {
13672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
13673 }
13674 arg2 = (PLINT)(val2);
13675 plsxax(arg1,arg2);
13676 resultobj = SWIG_Py_Void();
13677 return resultobj;
13678fail:
13679 return NULL;
13680}
13681
13682
13683SWIGINTERN PyObject *_wrap_plsyax(PyObject *self, PyObject *args) {
13684 PyObject *resultobj = 0;
13685 PLINT arg1 ;
13686 PLINT arg2 ;
13687 int val1 ;
13688 int ecode1 = 0 ;
13689 int val2 ;
13690 int ecode2 = 0 ;
13691 PyObject *swig_obj[2] ;
13692
13693 (void)self;
13694 if (!SWIG_Python_UnpackTuple(args, "plsyax", 2, 2, swig_obj)) SWIG_fail;
13695 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13696 if (!SWIG_IsOK(ecode1)) {
13697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
13698 }
13699 arg1 = (PLINT)(val1);
13700 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13701 if (!SWIG_IsOK(ecode2)) {
13702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
13703 }
13704 arg2 = (PLINT)(val2);
13705 plsyax(arg1,arg2);
13706 resultobj = SWIG_Py_Void();
13707 return resultobj;
13708fail:
13709 return NULL;
13710}
13711
13712
13713SWIGINTERN PyObject *_wrap_plsym(PyObject *self, PyObject *args) {
13714 PyObject *resultobj = 0;
13715 PLINT arg1 ;
13716 PLFLT *arg2 = (PLFLT *) 0 ;
13717 PLFLT *arg3 = (PLFLT *) 0 ;
13718 PLINT arg4 ;
13719 PyArrayObject *tmp1 = NULL ;
13720 PyArrayObject *tmp3 = NULL ;
13721 int val4 ;
13722 int ecode4 = 0 ;
13723 PyObject *swig_obj[3] ;
13724
13725 (void)self;
13726 if (!SWIG_Python_UnpackTuple(args, "plsym", 3, 3, swig_obj)) SWIG_fail;
13727 {
13728 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 1, 1 );
13729 if ( tmp1 == NULL )
13730 return NULL;
13731 arg1 = Alen = PyArray_DIMS( tmp1 )[0];
13732 arg2 = (PLFLT *) PyArray_DATA( tmp1 );
13733 }
13734 {
13735 tmp3 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 1, 1 );
13736 if ( tmp3 == NULL )
13737 return NULL;
13738 if ( PyArray_DIMS( tmp3 )[0] != Alen )
13739 {
13740 PyErr_SetString( PyExc_ValueError, "Vectors must be same length." );
13741 return NULL;
13742 }
13743 arg3 = (PLFLT *) PyArray_DATA( tmp3 );
13744 }
13745 ecode4 = SWIG_AsVal_int(swig_obj[2], &val4);
13746 if (!SWIG_IsOK(ecode4)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
13748 }
13749 arg4 = (PLINT)(val4);
13750 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
13751 resultobj = SWIG_Py_Void();
13752 {
13753 Py_CLEAR( tmp1 );
13754 }
13755 {
13756 Py_CLEAR( tmp3 );
13757 }
13758 return resultobj;
13759fail:
13760 {
13761 Py_CLEAR( tmp1 );
13762 }
13763 {
13764 Py_CLEAR( tmp3 );
13765 }
13766 return NULL;
13767}
13768
13769
13770SWIGINTERN PyObject *_wrap_plszax(PyObject *self, PyObject *args) {
13771 PyObject *resultobj = 0;
13772 PLINT arg1 ;
13773 PLINT arg2 ;
13774 int val1 ;
13775 int ecode1 = 0 ;
13776 int val2 ;
13777 int ecode2 = 0 ;
13778 PyObject *swig_obj[2] ;
13779
13780 (void)self;
13781 if (!SWIG_Python_UnpackTuple(args, "plszax", 2, 2, swig_obj)) SWIG_fail;
13782 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
13783 if (!SWIG_IsOK(ecode1)) {
13784 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
13785 }
13786 arg1 = (PLINT)(val1);
13787 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13788 if (!SWIG_IsOK(ecode2)) {
13789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
13790 }
13791 arg2 = (PLINT)(val2);
13792 plszax(arg1,arg2);
13793 resultobj = SWIG_Py_Void();
13794 return resultobj;
13795fail:
13796 return NULL;
13797}
13798
13799
13800SWIGINTERN PyObject *_wrap_pltext(PyObject *self, PyObject *args) {
13801 PyObject *resultobj = 0;
13802
13803 (void)self;
13804 if (!SWIG_Python_UnpackTuple(args, "pltext", 0, 0, 0)) SWIG_fail;
13805 pltext();
13806 resultobj = SWIG_Py_Void();
13807 return resultobj;
13808fail:
13809 return NULL;
13810}
13811
13812
13813SWIGINTERN PyObject *_wrap_pltimefmt(PyObject *self, PyObject *args) {
13814 PyObject *resultobj = 0;
13815 char *arg1 = (char *) 0 ;
13816 int res1 ;
13817 char *buf1 = 0 ;
13818 int alloc1 = 0 ;
13819 PyObject *swig_obj[1] ;
13820
13821 (void)self;
13822 if (!args) SWIG_fail;
13823 swig_obj[0] = args;
13824 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
13825 if (!SWIG_IsOK(res1)) {
13826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
13827 }
13828 arg1 = (char *)(buf1);
13829 pltimefmt((char const *)arg1);
13830 resultobj = SWIG_Py_Void();
13831 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13832 return resultobj;
13833fail:
13834 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
13835 return NULL;
13836}
13837
13838
13839SWIGINTERN PyObject *_wrap_plvasp(PyObject *self, PyObject *args) {
13840 PyObject *resultobj = 0;
13841 PLFLT arg1 ;
13842 double val1 ;
13843 int ecode1 = 0 ;
13844 PyObject *swig_obj[1] ;
13845
13846 (void)self;
13847 if (!args) SWIG_fail;
13848 swig_obj[0] = args;
13849 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
13850 if (!SWIG_IsOK(ecode1)) {
13851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
13852 }
13853 arg1 = (PLFLT)(val1);
13854 plvasp(arg1);
13855 resultobj = SWIG_Py_Void();
13856 return resultobj;
13857fail:
13858 return NULL;
13859}
13860
13861
13862SWIGINTERN PyObject *_wrap_plvect(PyObject *self, PyObject *args) {
13863 PyObject *resultobj = 0;
13864 PLFLT **arg1 = (PLFLT **) 0 ;
13865 PLFLT **arg2 = (PLFLT **) 0 ;
13866 PLINT arg3 ;
13867 PLINT arg4 ;
13868 PLFLT arg5 ;
13869 pltr_func arg6 = (pltr_func) 0 ;
13870 PLPointer arg7 = (PLPointer) 0 ;
13871 PyArrayObject *tmp1 = NULL ;
13872 PyArrayObject *tmp2 = NULL ;
13873 double val5 ;
13874 int ecode5 = 0 ;
13875 PyObject *swig_obj[5] ;
13876
13877 {
13878 python_pltr = 0;
13879 arg6 = NULL;
13880 }
13881 {
13882 arg7 = NULL;
13883 }
13884 (void)self;
13885 if (!SWIG_Python_UnpackTuple(args, "plvect", 3, 5, swig_obj)) SWIG_fail;
13886 {
13887 int i, size;
13888 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
13889 if ( tmp1 == NULL )
13890 return NULL;
13891 Xlen = PyArray_DIMS( tmp1 )[0];
13892 Ylen = PyArray_DIMS( tmp1 )[1];
13893 size = Ylen;
13894 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) Xlen );
13895 for ( i = 0; i < Xlen; i++ )
13896 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
13897 }
13898 {
13899 int i, size;
13900 tmp2 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[1], NPY_PLFLT, 2, 2 );
13901 if ( tmp2 == NULL )
13902 return NULL;
13903 if ( Xlen != PyArray_DIMS( tmp2 )[0] || Ylen != PyArray_DIMS( tmp2 )[1] )
13904 {
13905 PyErr_SetString( PyExc_ValueError, "Vectors must match matrix." );
13906 return NULL;
13907 }
13908 arg3 = PyArray_DIMS( tmp2 )[0];
13909 arg4 = PyArray_DIMS( tmp2 )[1];
13910 size = arg4;
13911 arg2 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg3 );
13912 for ( i = 0; i < arg3; i++ )
13913 arg2[i] = ( (PLFLT *) PyArray_DATA( tmp2 ) + i * size );
13914 }
13915 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
13916 if (!SWIG_IsOK(ecode5)) {
13917 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
13918 }
13919 arg5 = (PLFLT)(val5);
13920 if (swig_obj[3]) {
13921 {
13922 // it must be a callable or None
13923 if ( swig_obj[3] == Py_None )
13924 {
13925 arg6 = NULL;
13926 }
13927 else
13928 {
13929 if ( !PyCallable_Check( (PyObject *) swig_obj[3] ) )
13930 {
13931 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
13932 return NULL;
13933 }
13934 arg6 = marshal_pltr( swig_obj[3] );
13935 }
13936 }
13937 }
13938 if (swig_obj[4]) {
13939 {
13940 if ( swig_obj[4] == Py_None )
13941 arg7 = NULL;
13942 else
13943 {
13944 arg7 = marshal_PLPointer( swig_obj[4], 0 );
13945 }
13946 }
13947 }
13948 plvect((double const **)arg1,(double const **)arg2,arg3,arg4,arg5,arg6,arg7);
13949 resultobj = SWIG_Py_Void();
13950 {
13951 Py_CLEAR( tmp1 );
13952 free( arg1 );
13953 }
13954 {
13955 Py_CLEAR( tmp2 );
13956 free( arg2 );
13957 }
13958 {
13959 cleanup_pltr();
13960 }
13961 {
13963 }
13964 return resultobj;
13965fail:
13966 {
13967 Py_CLEAR( tmp1 );
13968 free( arg1 );
13969 }
13970 {
13971 Py_CLEAR( tmp2 );
13972 free( arg2 );
13973 }
13974 {
13975 cleanup_pltr();
13976 }
13977 {
13979 }
13980 return NULL;
13981}
13982
13983
13984SWIGINTERN PyObject *_wrap_plvpas(PyObject *self, PyObject *args) {
13985 PyObject *resultobj = 0;
13986 PLFLT arg1 ;
13987 PLFLT arg2 ;
13988 PLFLT arg3 ;
13989 PLFLT arg4 ;
13990 PLFLT arg5 ;
13991 double val1 ;
13992 int ecode1 = 0 ;
13993 double val2 ;
13994 int ecode2 = 0 ;
13995 double val3 ;
13996 int ecode3 = 0 ;
13997 double val4 ;
13998 int ecode4 = 0 ;
13999 double val5 ;
14000 int ecode5 = 0 ;
14001 PyObject *swig_obj[5] ;
14002
14003 (void)self;
14004 if (!SWIG_Python_UnpackTuple(args, "plvpas", 5, 5, swig_obj)) SWIG_fail;
14005 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14006 if (!SWIG_IsOK(ecode1)) {
14007 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
14008 }
14009 arg1 = (PLFLT)(val1);
14010 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14011 if (!SWIG_IsOK(ecode2)) {
14012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
14013 }
14014 arg2 = (PLFLT)(val2);
14015 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14016 if (!SWIG_IsOK(ecode3)) {
14017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
14018 }
14019 arg3 = (PLFLT)(val3);
14020 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14021 if (!SWIG_IsOK(ecode4)) {
14022 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
14023 }
14024 arg4 = (PLFLT)(val4);
14025 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14026 if (!SWIG_IsOK(ecode5)) {
14027 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
14028 }
14029 arg5 = (PLFLT)(val5);
14030 plvpas(arg1,arg2,arg3,arg4,arg5);
14031 resultobj = SWIG_Py_Void();
14032 return resultobj;
14033fail:
14034 return NULL;
14035}
14036
14037
14038SWIGINTERN PyObject *_wrap_plvpor(PyObject *self, PyObject *args) {
14039 PyObject *resultobj = 0;
14040 PLFLT arg1 ;
14041 PLFLT arg2 ;
14042 PLFLT arg3 ;
14043 PLFLT arg4 ;
14044 double val1 ;
14045 int ecode1 = 0 ;
14046 double val2 ;
14047 int ecode2 = 0 ;
14048 double val3 ;
14049 int ecode3 = 0 ;
14050 double val4 ;
14051 int ecode4 = 0 ;
14052 PyObject *swig_obj[4] ;
14053
14054 (void)self;
14055 if (!SWIG_Python_UnpackTuple(args, "plvpor", 4, 4, swig_obj)) SWIG_fail;
14056 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14057 if (!SWIG_IsOK(ecode1)) {
14058 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
14059 }
14060 arg1 = (PLFLT)(val1);
14061 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14062 if (!SWIG_IsOK(ecode2)) {
14063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
14064 }
14065 arg2 = (PLFLT)(val2);
14066 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14067 if (!SWIG_IsOK(ecode3)) {
14068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
14069 }
14070 arg3 = (PLFLT)(val3);
14071 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14072 if (!SWIG_IsOK(ecode4)) {
14073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
14074 }
14075 arg4 = (PLFLT)(val4);
14076 plvpor(arg1,arg2,arg3,arg4);
14077 resultobj = SWIG_Py_Void();
14078 return resultobj;
14079fail:
14080 return NULL;
14081}
14082
14083
14084SWIGINTERN PyObject *_wrap_plvsta(PyObject *self, PyObject *args) {
14085 PyObject *resultobj = 0;
14086
14087 (void)self;
14088 if (!SWIG_Python_UnpackTuple(args, "plvsta", 0, 0, 0)) SWIG_fail;
14089 plvsta();
14090 resultobj = SWIG_Py_Void();
14091 return resultobj;
14092fail:
14093 return NULL;
14094}
14095
14096
14097SWIGINTERN PyObject *_wrap_plw3d(PyObject *self, PyObject *args) {
14098 PyObject *resultobj = 0;
14099 PLFLT arg1 ;
14100 PLFLT arg2 ;
14101 PLFLT arg3 ;
14102 PLFLT arg4 ;
14103 PLFLT arg5 ;
14104 PLFLT arg6 ;
14105 PLFLT arg7 ;
14106 PLFLT arg8 ;
14107 PLFLT arg9 ;
14108 PLFLT arg10 ;
14109 PLFLT arg11 ;
14110 double val1 ;
14111 int ecode1 = 0 ;
14112 double val2 ;
14113 int ecode2 = 0 ;
14114 double val3 ;
14115 int ecode3 = 0 ;
14116 double val4 ;
14117 int ecode4 = 0 ;
14118 double val5 ;
14119 int ecode5 = 0 ;
14120 double val6 ;
14121 int ecode6 = 0 ;
14122 double val7 ;
14123 int ecode7 = 0 ;
14124 double val8 ;
14125 int ecode8 = 0 ;
14126 double val9 ;
14127 int ecode9 = 0 ;
14128 double val10 ;
14129 int ecode10 = 0 ;
14130 double val11 ;
14131 int ecode11 = 0 ;
14132 PyObject *swig_obj[11] ;
14133
14134 (void)self;
14135 if (!SWIG_Python_UnpackTuple(args, "plw3d", 11, 11, swig_obj)) SWIG_fail;
14136 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14137 if (!SWIG_IsOK(ecode1)) {
14138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
14139 }
14140 arg1 = (PLFLT)(val1);
14141 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14142 if (!SWIG_IsOK(ecode2)) {
14143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
14144 }
14145 arg2 = (PLFLT)(val2);
14146 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14147 if (!SWIG_IsOK(ecode3)) {
14148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
14149 }
14150 arg3 = (PLFLT)(val3);
14151 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14152 if (!SWIG_IsOK(ecode4)) {
14153 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
14154 }
14155 arg4 = (PLFLT)(val4);
14156 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14157 if (!SWIG_IsOK(ecode5)) {
14158 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
14159 }
14160 arg5 = (PLFLT)(val5);
14161 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14162 if (!SWIG_IsOK(ecode6)) {
14163 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
14164 }
14165 arg6 = (PLFLT)(val6);
14166 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14167 if (!SWIG_IsOK(ecode7)) {
14168 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
14169 }
14170 arg7 = (PLFLT)(val7);
14171 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14172 if (!SWIG_IsOK(ecode8)) {
14173 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
14174 }
14175 arg8 = (PLFLT)(val8);
14176 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14177 if (!SWIG_IsOK(ecode9)) {
14178 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
14179 }
14180 arg9 = (PLFLT)(val9);
14181 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14182 if (!SWIG_IsOK(ecode10)) {
14183 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
14184 }
14185 arg10 = (PLFLT)(val10);
14186 ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
14187 if (!SWIG_IsOK(ecode11)) {
14188 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
14189 }
14190 arg11 = (PLFLT)(val11);
14191 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14192 resultobj = SWIG_Py_Void();
14193 return resultobj;
14194fail:
14195 return NULL;
14196}
14197
14198
14199SWIGINTERN PyObject *_wrap_plwidth(PyObject *self, PyObject *args) {
14200 PyObject *resultobj = 0;
14201 PLFLT arg1 ;
14202 double val1 ;
14203 int ecode1 = 0 ;
14204 PyObject *swig_obj[1] ;
14205
14206 (void)self;
14207 if (!args) SWIG_fail;
14208 swig_obj[0] = args;
14209 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14210 if (!SWIG_IsOK(ecode1)) {
14211 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
14212 }
14213 arg1 = (PLFLT)(val1);
14214 plwidth(arg1);
14215 resultobj = SWIG_Py_Void();
14216 return resultobj;
14217fail:
14218 return NULL;
14219}
14220
14221
14222SWIGINTERN PyObject *_wrap_plwind(PyObject *self, PyObject *args) {
14223 PyObject *resultobj = 0;
14224 PLFLT arg1 ;
14225 PLFLT arg2 ;
14226 PLFLT arg3 ;
14227 PLFLT arg4 ;
14228 double val1 ;
14229 int ecode1 = 0 ;
14230 double val2 ;
14231 int ecode2 = 0 ;
14232 double val3 ;
14233 int ecode3 = 0 ;
14234 double val4 ;
14235 int ecode4 = 0 ;
14236 PyObject *swig_obj[4] ;
14237
14238 (void)self;
14239 if (!SWIG_Python_UnpackTuple(args, "plwind", 4, 4, swig_obj)) SWIG_fail;
14240 ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
14241 if (!SWIG_IsOK(ecode1)) {
14242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
14243 }
14244 arg1 = (PLFLT)(val1);
14245 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14246 if (!SWIG_IsOK(ecode2)) {
14247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
14248 }
14249 arg2 = (PLFLT)(val2);
14250 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14251 if (!SWIG_IsOK(ecode3)) {
14252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
14253 }
14254 arg3 = (PLFLT)(val3);
14255 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14256 if (!SWIG_IsOK(ecode4)) {
14257 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
14258 }
14259 arg4 = (PLFLT)(val4);
14260 plwind(arg1,arg2,arg3,arg4);
14261 resultobj = SWIG_Py_Void();
14262 return resultobj;
14263fail:
14264 return NULL;
14265}
14266
14267
14268SWIGINTERN PyObject *_wrap_plxormod(PyObject *self, PyObject *args) {
14269 PyObject *resultobj = 0;
14270 PLBOOL arg1 ;
14271 PLBOOL *arg2 = (PLBOOL *) 0 ;
14272 int val1 ;
14273 int ecode1 = 0 ;
14274 PLBOOL temp2 ;
14275 int res2 = SWIG_TMPOBJ ;
14276 PyObject *swig_obj[1] ;
14277
14278 arg2 = &temp2;
14279 (void)self;
14280 if (!args) SWIG_fail;
14281 swig_obj[0] = args;
14282 ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
14283 if (!SWIG_IsOK(ecode1)) {
14284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
14285 }
14286 arg1 = (PLBOOL)(val1);
14287 plxormod(arg1,arg2);
14288 resultobj = SWIG_Py_Void();
14289 if (SWIG_IsTmpObj(res2)) {
14290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)), 1);
14291 } else {
14292 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags), 1);
14294 }
14295 return resultobj;
14296fail:
14297 return NULL;
14298}
14299
14300
14301SWIGINTERN PyObject *_wrap_plmap(PyObject *self, PyObject *args) {
14302 PyObject *resultobj = 0;
14303 mapform_func arg1 = (mapform_func) 0 ;
14304 char *arg2 = (char *) 0 ;
14305 PLFLT arg3 ;
14306 PLFLT arg4 ;
14307 PLFLT arg5 ;
14308 PLFLT arg6 ;
14309 int res2 ;
14310 char *buf2 = 0 ;
14311 int alloc2 = 0 ;
14312 double val3 ;
14313 int ecode3 = 0 ;
14314 double val4 ;
14315 int ecode4 = 0 ;
14316 double val5 ;
14317 int ecode5 = 0 ;
14318 double val6 ;
14319 int ecode6 = 0 ;
14320 PyObject *swig_obj[6] ;
14321
14322 (void)self;
14323 if (!SWIG_Python_UnpackTuple(args, "plmap", 6, 6, swig_obj)) SWIG_fail;
14324 {
14325 // it must be a callable or none
14326 if ( swig_obj[0] == Py_None )
14327 {
14328 arg1 = NULL;
14329 }
14330 else
14331 {
14332 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14333 {
14334 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14335 return NULL;
14336 }
14337 arg1 = marshal_mapform( swig_obj[0] );
14338 }
14339 }
14340 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14341 if (!SWIG_IsOK(res2)) {
14342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
14343 }
14344 arg2 = (char *)(buf2);
14345 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14346 if (!SWIG_IsOK(ecode3)) {
14347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
14348 }
14349 arg3 = (PLFLT)(val3);
14350 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14351 if (!SWIG_IsOK(ecode4)) {
14352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
14353 }
14354 arg4 = (PLFLT)(val4);
14355 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14356 if (!SWIG_IsOK(ecode5)) {
14357 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
14358 }
14359 arg5 = (PLFLT)(val5);
14360 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14361 if (!SWIG_IsOK(ecode6)) {
14362 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
14363 }
14364 arg6 = (PLFLT)(val6);
14365 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
14366 resultobj = SWIG_Py_Void();
14367 {
14369 }
14370 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14371 return resultobj;
14372fail:
14373 {
14375 }
14376 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14377 return NULL;
14378}
14379
14380
14381SWIGINTERN PyObject *_wrap_plmapline(PyObject *self, PyObject *args) {
14382 PyObject *resultobj = 0;
14383 mapform_func arg1 = (mapform_func) 0 ;
14384 char *arg2 = (char *) 0 ;
14385 PLFLT arg3 ;
14386 PLFLT arg4 ;
14387 PLFLT arg5 ;
14388 PLFLT arg6 ;
14389 PLINT *arg7 = (PLINT *) 0 ;
14390 PLINT arg8 ;
14391 int res2 ;
14392 char *buf2 = 0 ;
14393 int alloc2 = 0 ;
14394 double val3 ;
14395 int ecode3 = 0 ;
14396 double val4 ;
14397 int ecode4 = 0 ;
14398 double val5 ;
14399 int ecode5 = 0 ;
14400 double val6 ;
14401 int ecode6 = 0 ;
14402 PyArrayObject *tmp7 = NULL ;
14403 PyObject *swig_obj[7] ;
14404
14405 (void)self;
14406 if (!SWIG_Python_UnpackTuple(args, "plmapline", 7, 7, swig_obj)) SWIG_fail;
14407 {
14408 // it must be a callable or none
14409 if ( swig_obj[0] == Py_None )
14410 {
14411 arg1 = NULL;
14412 }
14413 else
14414 {
14415 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14416 {
14417 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14418 return NULL;
14419 }
14420 arg1 = marshal_mapform( swig_obj[0] );
14421 }
14422 }
14423 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14424 if (!SWIG_IsOK(res2)) {
14425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
14426 }
14427 arg2 = (char *)(buf2);
14428 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14429 if (!SWIG_IsOK(ecode3)) {
14430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
14431 }
14432 arg3 = (PLFLT)(val3);
14433 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14434 if (!SWIG_IsOK(ecode4)) {
14435 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
14436 }
14437 arg4 = (PLFLT)(val4);
14438 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14439 if (!SWIG_IsOK(ecode5)) {
14440 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
14441 }
14442 arg5 = (PLFLT)(val5);
14443 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14444 if (!SWIG_IsOK(ecode6)) {
14445 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
14446 }
14447 arg6 = (PLFLT)(val6);
14448 {
14449 if ( swig_obj[6] != Py_None )
14450 {
14451 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14452 if ( tmp7 == NULL )
14453 return NULL;
14454 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14455 arg8 = PyArray_DIMS( tmp7 )[0];
14456 }
14457 else
14458 {
14459 arg7 = NULL;
14460 arg8 = 0;
14461 }
14462 }
14463 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14464 resultobj = SWIG_Py_Void();
14465 {
14467 }
14468 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14469 {
14470 Py_CLEAR( tmp7 );
14471 }
14472 return resultobj;
14473fail:
14474 {
14476 }
14477 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14478 {
14479 Py_CLEAR( tmp7 );
14480 }
14481 return NULL;
14482}
14483
14484
14485SWIGINTERN PyObject *_wrap_plmapstring(PyObject *self, PyObject *args) {
14486 PyObject *resultobj = 0;
14487 mapform_func arg1 = (mapform_func) 0 ;
14488 char *arg2 = (char *) 0 ;
14489 char *arg3 = (char *) 0 ;
14490 PLFLT arg4 ;
14491 PLFLT arg5 ;
14492 PLFLT arg6 ;
14493 PLFLT arg7 ;
14494 PLINT *arg8 = (PLINT *) 0 ;
14495 PLINT arg9 ;
14496 int res2 ;
14497 char *buf2 = 0 ;
14498 int alloc2 = 0 ;
14499 int res3 ;
14500 char *buf3 = 0 ;
14501 int alloc3 = 0 ;
14502 double val4 ;
14503 int ecode4 = 0 ;
14504 double val5 ;
14505 int ecode5 = 0 ;
14506 double val6 ;
14507 int ecode6 = 0 ;
14508 double val7 ;
14509 int ecode7 = 0 ;
14510 PyArrayObject *tmp8 = NULL ;
14511 PyObject *swig_obj[8] ;
14512
14513 (void)self;
14514 if (!SWIG_Python_UnpackTuple(args, "plmapstring", 8, 8, swig_obj)) SWIG_fail;
14515 {
14516 // it must be a callable or none
14517 if ( swig_obj[0] == Py_None )
14518 {
14519 arg1 = NULL;
14520 }
14521 else
14522 {
14523 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14524 {
14525 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14526 return NULL;
14527 }
14528 arg1 = marshal_mapform( swig_obj[0] );
14529 }
14530 }
14531 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14532 if (!SWIG_IsOK(res2)) {
14533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
14534 }
14535 arg2 = (char *)(buf2);
14536 res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
14537 if (!SWIG_IsOK(res3)) {
14538 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
14539 }
14540 arg3 = (char *)(buf3);
14541 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14542 if (!SWIG_IsOK(ecode4)) {
14543 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
14544 }
14545 arg4 = (PLFLT)(val4);
14546 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14547 if (!SWIG_IsOK(ecode5)) {
14548 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
14549 }
14550 arg5 = (PLFLT)(val5);
14551 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14552 if (!SWIG_IsOK(ecode6)) {
14553 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
14554 }
14555 arg6 = (PLFLT)(val6);
14556 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14557 if (!SWIG_IsOK(ecode7)) {
14558 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
14559 }
14560 arg7 = (PLFLT)(val7);
14561 {
14562 if ( swig_obj[7] != Py_None )
14563 {
14564 tmp8 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[7], NPY_PLINT, 1, 1 );
14565 if ( tmp8 == NULL )
14566 return NULL;
14567 arg8 = (PLINT *) PyArray_DATA( tmp8 );
14568 arg9 = PyArray_DIMS( tmp8 )[0];
14569 }
14570 else
14571 {
14572 arg8 = NULL;
14573 arg9 = 0;
14574 }
14575 }
14576 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
14577 resultobj = SWIG_Py_Void();
14578 {
14580 }
14581 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14582 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14583 {
14584 Py_CLEAR( tmp8 );
14585 }
14586 return resultobj;
14587fail:
14588 {
14590 }
14591 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14592 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
14593 {
14594 Py_CLEAR( tmp8 );
14595 }
14596 return NULL;
14597}
14598
14599
14600SWIGINTERN PyObject *_wrap_plmaptex(PyObject *self, PyObject *args) {
14601 PyObject *resultobj = 0;
14602 mapform_func arg1 = (mapform_func) 0 ;
14603 char *arg2 = (char *) 0 ;
14604 PLFLT arg3 ;
14605 PLFLT arg4 ;
14606 PLFLT arg5 ;
14607 char *arg6 = (char *) 0 ;
14608 PLFLT arg7 ;
14609 PLFLT arg8 ;
14610 PLFLT arg9 ;
14611 PLFLT arg10 ;
14612 PLINT arg11 ;
14613 int res2 ;
14614 char *buf2 = 0 ;
14615 int alloc2 = 0 ;
14616 double val3 ;
14617 int ecode3 = 0 ;
14618 double val4 ;
14619 int ecode4 = 0 ;
14620 double val5 ;
14621 int ecode5 = 0 ;
14622 int res6 ;
14623 char *buf6 = 0 ;
14624 int alloc6 = 0 ;
14625 double val7 ;
14626 int ecode7 = 0 ;
14627 double val8 ;
14628 int ecode8 = 0 ;
14629 double val9 ;
14630 int ecode9 = 0 ;
14631 double val10 ;
14632 int ecode10 = 0 ;
14633 int val11 ;
14634 int ecode11 = 0 ;
14635 PyObject *swig_obj[11] ;
14636
14637 (void)self;
14638 if (!SWIG_Python_UnpackTuple(args, "plmaptex", 11, 11, swig_obj)) SWIG_fail;
14639 {
14640 // it must be a callable or none
14641 if ( swig_obj[0] == Py_None )
14642 {
14643 arg1 = NULL;
14644 }
14645 else
14646 {
14647 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14648 {
14649 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14650 return NULL;
14651 }
14652 arg1 = marshal_mapform( swig_obj[0] );
14653 }
14654 }
14655 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14656 if (!SWIG_IsOK(res2)) {
14657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
14658 }
14659 arg2 = (char *)(buf2);
14660 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14661 if (!SWIG_IsOK(ecode3)) {
14662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
14663 }
14664 arg3 = (PLFLT)(val3);
14665 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14666 if (!SWIG_IsOK(ecode4)) {
14667 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
14668 }
14669 arg4 = (PLFLT)(val4);
14670 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14671 if (!SWIG_IsOK(ecode5)) {
14672 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
14673 }
14674 arg5 = (PLFLT)(val5);
14675 res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
14676 if (!SWIG_IsOK(res6)) {
14677 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
14678 }
14679 arg6 = (char *)(buf6);
14680 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14681 if (!SWIG_IsOK(ecode7)) {
14682 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
14683 }
14684 arg7 = (PLFLT)(val7);
14685 ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
14686 if (!SWIG_IsOK(ecode8)) {
14687 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
14688 }
14689 arg8 = (PLFLT)(val8);
14690 ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
14691 if (!SWIG_IsOK(ecode9)) {
14692 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
14693 }
14694 arg9 = (PLFLT)(val9);
14695 ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
14696 if (!SWIG_IsOK(ecode10)) {
14697 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
14698 }
14699 arg10 = (PLFLT)(val10);
14700 ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
14701 if (!SWIG_IsOK(ecode11)) {
14702 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
14703 }
14704 arg11 = (PLINT)(val11);
14705 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
14706 resultobj = SWIG_Py_Void();
14707 {
14709 }
14710 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14711 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14712 return resultobj;
14713fail:
14714 {
14716 }
14717 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14718 if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
14719 return NULL;
14720}
14721
14722
14723SWIGINTERN PyObject *_wrap_plmapfill(PyObject *self, PyObject *args) {
14724 PyObject *resultobj = 0;
14725 mapform_func arg1 = (mapform_func) 0 ;
14726 char *arg2 = (char *) 0 ;
14727 PLFLT arg3 ;
14728 PLFLT arg4 ;
14729 PLFLT arg5 ;
14730 PLFLT arg6 ;
14731 PLINT *arg7 = (PLINT *) 0 ;
14732 PLINT arg8 ;
14733 int res2 ;
14734 char *buf2 = 0 ;
14735 int alloc2 = 0 ;
14736 double val3 ;
14737 int ecode3 = 0 ;
14738 double val4 ;
14739 int ecode4 = 0 ;
14740 double val5 ;
14741 int ecode5 = 0 ;
14742 double val6 ;
14743 int ecode6 = 0 ;
14744 PyArrayObject *tmp7 = NULL ;
14745 PyObject *swig_obj[7] ;
14746
14747 (void)self;
14748 if (!SWIG_Python_UnpackTuple(args, "plmapfill", 7, 7, swig_obj)) SWIG_fail;
14749 {
14750 // it must be a callable or none
14751 if ( swig_obj[0] == Py_None )
14752 {
14753 arg1 = NULL;
14754 }
14755 else
14756 {
14757 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14758 {
14759 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14760 return NULL;
14761 }
14762 arg1 = marshal_mapform( swig_obj[0] );
14763 }
14764 }
14765 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
14766 if (!SWIG_IsOK(res2)) {
14767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
14768 }
14769 arg2 = (char *)(buf2);
14770 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14771 if (!SWIG_IsOK(ecode3)) {
14772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
14773 }
14774 arg3 = (PLFLT)(val3);
14775 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14776 if (!SWIG_IsOK(ecode4)) {
14777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
14778 }
14779 arg4 = (PLFLT)(val4);
14780 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14781 if (!SWIG_IsOK(ecode5)) {
14782 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
14783 }
14784 arg5 = (PLFLT)(val5);
14785 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14786 if (!SWIG_IsOK(ecode6)) {
14787 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
14788 }
14789 arg6 = (PLFLT)(val6);
14790 {
14791 if ( swig_obj[6] != Py_None )
14792 {
14793 tmp7 = (PyArrayObject *) myIntArray_ContiguousFromObject( swig_obj[6], NPY_PLINT, 1, 1 );
14794 if ( tmp7 == NULL )
14795 return NULL;
14796 arg7 = (PLINT *) PyArray_DATA( tmp7 );
14797 arg8 = PyArray_DIMS( tmp7 )[0];
14798 }
14799 else
14800 {
14801 arg7 = NULL;
14802 arg8 = 0;
14803 }
14804 }
14805 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
14806 resultobj = SWIG_Py_Void();
14807 {
14809 }
14810 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14811 {
14812 Py_CLEAR( tmp7 );
14813 }
14814 return resultobj;
14815fail:
14816 {
14818 }
14819 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
14820 {
14821 Py_CLEAR( tmp7 );
14822 }
14823 return NULL;
14824}
14825
14826
14827SWIGINTERN PyObject *_wrap_plmeridians(PyObject *self, PyObject *args) {
14828 PyObject *resultobj = 0;
14829 mapform_func arg1 = (mapform_func) 0 ;
14830 PLFLT arg2 ;
14831 PLFLT arg3 ;
14832 PLFLT arg4 ;
14833 PLFLT arg5 ;
14834 PLFLT arg6 ;
14835 PLFLT arg7 ;
14836 double val2 ;
14837 int ecode2 = 0 ;
14838 double val3 ;
14839 int ecode3 = 0 ;
14840 double val4 ;
14841 int ecode4 = 0 ;
14842 double val5 ;
14843 int ecode5 = 0 ;
14844 double val6 ;
14845 int ecode6 = 0 ;
14846 double val7 ;
14847 int ecode7 = 0 ;
14848 PyObject *swig_obj[7] ;
14849
14850 (void)self;
14851 if (!SWIG_Python_UnpackTuple(args, "plmeridians", 7, 7, swig_obj)) SWIG_fail;
14852 {
14853 // it must be a callable or none
14854 if ( swig_obj[0] == Py_None )
14855 {
14856 arg1 = NULL;
14857 }
14858 else
14859 {
14860 if ( !PyCallable_Check( (PyObject *) swig_obj[0] ) )
14861 {
14862 PyErr_SetString( PyExc_ValueError, "mapform argument must be callable" );
14863 return NULL;
14864 }
14865 arg1 = marshal_mapform( swig_obj[0] );
14866 }
14867 }
14868 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
14869 if (!SWIG_IsOK(ecode2)) {
14870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
14871 }
14872 arg2 = (PLFLT)(val2);
14873 ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
14874 if (!SWIG_IsOK(ecode3)) {
14875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
14876 }
14877 arg3 = (PLFLT)(val3);
14878 ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
14879 if (!SWIG_IsOK(ecode4)) {
14880 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
14881 }
14882 arg4 = (PLFLT)(val4);
14883 ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
14884 if (!SWIG_IsOK(ecode5)) {
14885 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
14886 }
14887 arg5 = (PLFLT)(val5);
14888 ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
14889 if (!SWIG_IsOK(ecode6)) {
14890 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
14891 }
14892 arg6 = (PLFLT)(val6);
14893 ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
14894 if (!SWIG_IsOK(ecode7)) {
14895 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
14896 }
14897 arg7 = (PLFLT)(val7);
14898 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
14899 resultobj = SWIG_Py_Void();
14900 {
14902 }
14903 return resultobj;
14904fail:
14905 {
14907 }
14908 return NULL;
14909}
14910
14911
14912SWIGINTERN PyObject *_wrap_plimage(PyObject *self, PyObject *args) {
14913 PyObject *resultobj = 0;
14914 PLFLT **arg1 = (PLFLT **) 0 ;
14915 PLINT arg2 ;
14916 PLINT arg3 ;
14917 PLFLT arg4 ;
14918 PLFLT arg5 ;
14919 PLFLT arg6 ;
14920 PLFLT arg7 ;
14921 PLFLT arg8 ;
14922 PLFLT arg9 ;
14923 PLFLT arg10 ;
14924 PLFLT arg11 ;
14925 PLFLT arg12 ;
14926 PLFLT arg13 ;
14927 PyArrayObject *tmp1 = NULL ;
14928 double val4 ;
14929 int ecode4 = 0 ;
14930 double val5 ;
14931 int ecode5 = 0 ;
14932 double val6 ;
14933 int ecode6 = 0 ;
14934 double val7 ;
14935 int ecode7 = 0 ;
14936 double val8 ;
14937 int ecode8 = 0 ;
14938 double val9 ;
14939 int ecode9 = 0 ;
14940 double val10 ;
14941 int ecode10 = 0 ;
14942 double val11 ;
14943 int ecode11 = 0 ;
14944 double val12 ;
14945 int ecode12 = 0 ;
14946 double val13 ;
14947 int ecode13 = 0 ;
14948 PyObject *swig_obj[11] ;
14949
14950 (void)self;
14951 if (!SWIG_Python_UnpackTuple(args, "plimage", 11, 11, swig_obj)) SWIG_fail;
14952 {
14953 int i, size;
14954 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
14955 if ( tmp1 == NULL )
14956 return NULL;
14957 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
14958 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
14959 size = arg3;
14960 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
14961 for ( i = 0; i < arg2; i++ )
14962 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
14963 }
14964 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
14965 if (!SWIG_IsOK(ecode4)) {
14966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimage" "', argument " "4"" of type '" "PLFLT""'");
14967 }
14968 arg4 = (PLFLT)(val4);
14969 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
14970 if (!SWIG_IsOK(ecode5)) {
14971 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimage" "', argument " "5"" of type '" "PLFLT""'");
14972 }
14973 arg5 = (PLFLT)(val5);
14974 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
14975 if (!SWIG_IsOK(ecode6)) {
14976 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimage" "', argument " "6"" of type '" "PLFLT""'");
14977 }
14978 arg6 = (PLFLT)(val6);
14979 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
14980 if (!SWIG_IsOK(ecode7)) {
14981 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimage" "', argument " "7"" of type '" "PLFLT""'");
14982 }
14983 arg7 = (PLFLT)(val7);
14984 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
14985 if (!SWIG_IsOK(ecode8)) {
14986 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimage" "', argument " "8"" of type '" "PLFLT""'");
14987 }
14988 arg8 = (PLFLT)(val8);
14989 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
14990 if (!SWIG_IsOK(ecode9)) {
14991 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimage" "', argument " "9"" of type '" "PLFLT""'");
14992 }
14993 arg9 = (PLFLT)(val9);
14994 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
14995 if (!SWIG_IsOK(ecode10)) {
14996 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimage" "', argument " "10"" of type '" "PLFLT""'");
14997 }
14998 arg10 = (PLFLT)(val10);
14999 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
15000 if (!SWIG_IsOK(ecode11)) {
15001 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimage" "', argument " "11"" of type '" "PLFLT""'");
15002 }
15003 arg11 = (PLFLT)(val11);
15004 ecode12 = SWIG_AsVal_double(swig_obj[9], &val12);
15005 if (!SWIG_IsOK(ecode12)) {
15006 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plimage" "', argument " "12"" of type '" "PLFLT""'");
15007 }
15008 arg12 = (PLFLT)(val12);
15009 ecode13 = SWIG_AsVal_double(swig_obj[10], &val13);
15010 if (!SWIG_IsOK(ecode13)) {
15011 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plimage" "', argument " "13"" of type '" "PLFLT""'");
15012 }
15013 arg13 = (PLFLT)(val13);
15014 plimage((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15015 resultobj = SWIG_Py_Void();
15016 {
15017 Py_CLEAR( tmp1 );
15018 free( arg1 );
15019 }
15020 return resultobj;
15021fail:
15022 {
15023 Py_CLEAR( tmp1 );
15024 free( arg1 );
15025 }
15026 return NULL;
15027}
15028
15029
15030SWIGINTERN PyObject *_wrap_plimagefr(PyObject *self, PyObject *args) {
15031 PyObject *resultobj = 0;
15032 PLFLT **arg1 = (PLFLT **) 0 ;
15033 PLINT arg2 ;
15034 PLINT arg3 ;
15035 PLFLT arg4 ;
15036 PLFLT arg5 ;
15037 PLFLT arg6 ;
15038 PLFLT arg7 ;
15039 PLFLT arg8 ;
15040 PLFLT arg9 ;
15041 PLFLT arg10 ;
15042 PLFLT arg11 ;
15043 pltr_func arg12 = (pltr_func) 0 ;
15044 PLPointer arg13 = (PLPointer) 0 ;
15045 PyArrayObject *tmp1 = NULL ;
15046 double val4 ;
15047 int ecode4 = 0 ;
15048 double val5 ;
15049 int ecode5 = 0 ;
15050 double val6 ;
15051 int ecode6 = 0 ;
15052 double val7 ;
15053 int ecode7 = 0 ;
15054 double val8 ;
15055 int ecode8 = 0 ;
15056 double val9 ;
15057 int ecode9 = 0 ;
15058 double val10 ;
15059 int ecode10 = 0 ;
15060 double val11 ;
15061 int ecode11 = 0 ;
15062 PyObject *swig_obj[11] ;
15063
15064 {
15065 python_pltr = 0;
15066 arg12 = NULL;
15067 }
15068 {
15069 arg13 = NULL;
15070 }
15071 (void)self;
15072 if (!SWIG_Python_UnpackTuple(args, "plimagefr", 9, 11, swig_obj)) SWIG_fail;
15073 {
15074 int i, size;
15075 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15076 if ( tmp1 == NULL )
15077 return NULL;
15078 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15079 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15080 size = arg3;
15081 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15082 for ( i = 0; i < arg2; i++ )
15083 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15084 }
15085 ecode4 = SWIG_AsVal_double(swig_obj[1], &val4);
15086 if (!SWIG_IsOK(ecode4)) {
15087 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15088 }
15089 arg4 = (PLFLT)(val4);
15090 ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
15091 if (!SWIG_IsOK(ecode5)) {
15092 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15093 }
15094 arg5 = (PLFLT)(val5);
15095 ecode6 = SWIG_AsVal_double(swig_obj[3], &val6);
15096 if (!SWIG_IsOK(ecode6)) {
15097 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15098 }
15099 arg6 = (PLFLT)(val6);
15100 ecode7 = SWIG_AsVal_double(swig_obj[4], &val7);
15101 if (!SWIG_IsOK(ecode7)) {
15102 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15103 }
15104 arg7 = (PLFLT)(val7);
15105 ecode8 = SWIG_AsVal_double(swig_obj[5], &val8);
15106 if (!SWIG_IsOK(ecode8)) {
15107 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15108 }
15109 arg8 = (PLFLT)(val8);
15110 ecode9 = SWIG_AsVal_double(swig_obj[6], &val9);
15111 if (!SWIG_IsOK(ecode9)) {
15112 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15113 }
15114 arg9 = (PLFLT)(val9);
15115 ecode10 = SWIG_AsVal_double(swig_obj[7], &val10);
15116 if (!SWIG_IsOK(ecode10)) {
15117 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15118 }
15119 arg10 = (PLFLT)(val10);
15120 ecode11 = SWIG_AsVal_double(swig_obj[8], &val11);
15121 if (!SWIG_IsOK(ecode11)) {
15122 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15123 }
15124 arg11 = (PLFLT)(val11);
15125 if (swig_obj[9]) {
15126 {
15127 // it must be a callable or None
15128 if ( swig_obj[9] == Py_None )
15129 {
15130 arg12 = NULL;
15131 }
15132 else
15133 {
15134 if ( !PyCallable_Check( (PyObject *) swig_obj[9] ) )
15135 {
15136 PyErr_SetString( PyExc_ValueError, "pltr argument must be callable" );
15137 return NULL;
15138 }
15139 arg12 = marshal_pltr( swig_obj[9] );
15140 }
15141 }
15142 }
15143 if (swig_obj[10]) {
15144 {
15145 if ( swig_obj[10] == Py_None )
15146 arg13 = NULL;
15147 else
15148 {
15149 arg13 = marshal_PLPointer( swig_obj[10], 1 );
15150 }
15151 }
15152 }
15153 plimagefr((double const **)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15154 resultobj = SWIG_Py_Void();
15155 {
15156 Py_CLEAR( tmp1 );
15157 free( arg1 );
15158 }
15159 {
15160 cleanup_pltr();
15161 }
15162 {
15164 }
15165 return resultobj;
15166fail:
15167 {
15168 Py_CLEAR( tmp1 );
15169 free( arg1 );
15170 }
15171 {
15172 cleanup_pltr();
15173 }
15174 {
15176 }
15177 return NULL;
15178}
15179
15180
15181SWIGINTERN PyObject *_wrap_plClearOpts(PyObject *self, PyObject *args) {
15182 PyObject *resultobj = 0;
15183
15184 (void)self;
15185 if (!SWIG_Python_UnpackTuple(args, "plClearOpts", 0, 0, 0)) SWIG_fail;
15186 plClearOpts();
15187 resultobj = SWIG_Py_Void();
15188 return resultobj;
15189fail:
15190 return NULL;
15191}
15192
15193
15194SWIGINTERN PyObject *_wrap_plResetOpts(PyObject *self, PyObject *args) {
15195 PyObject *resultobj = 0;
15196
15197 (void)self;
15198 if (!SWIG_Python_UnpackTuple(args, "plResetOpts", 0, 0, 0)) SWIG_fail;
15199 plResetOpts();
15200 resultobj = SWIG_Py_Void();
15201 return resultobj;
15202fail:
15203 return NULL;
15204}
15205
15206
15207SWIGINTERN PyObject *_wrap_plSetUsage(PyObject *self, PyObject *args) {
15208 PyObject *resultobj = 0;
15209 char *arg1 = (char *) 0 ;
15210 char *arg2 = (char *) 0 ;
15211 int res1 ;
15212 char *buf1 = 0 ;
15213 int alloc1 = 0 ;
15214 int res2 ;
15215 char *buf2 = 0 ;
15216 int alloc2 = 0 ;
15217 PyObject *swig_obj[2] ;
15218
15219 (void)self;
15220 if (!SWIG_Python_UnpackTuple(args, "plSetUsage", 2, 2, swig_obj)) SWIG_fail;
15221 res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
15222 if (!SWIG_IsOK(res1)) {
15223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
15224 }
15225 arg1 = (char *)(buf1);
15226 res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
15227 if (!SWIG_IsOK(res2)) {
15228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
15229 }
15230 arg2 = (char *)(buf2);
15231 plSetUsage((char const *)arg1,(char const *)arg2);
15232 resultobj = SWIG_Py_Void();
15233 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15234 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15235 return resultobj;
15236fail:
15237 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
15238 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15239 return NULL;
15240}
15241
15242
15243SWIGINTERN PyObject *_wrap_plOptUsage(PyObject *self, PyObject *args) {
15244 PyObject *resultobj = 0;
15245
15246 (void)self;
15247 if (!SWIG_Python_UnpackTuple(args, "plOptUsage", 0, 0, 0)) SWIG_fail;
15248 plOptUsage();
15249 resultobj = SWIG_Py_Void();
15250 return resultobj;
15251fail:
15252 return NULL;
15253}
15254
15255
15256SWIGINTERN PyObject *_wrap_plMinMax2dGrid(PyObject *self, PyObject *args) {
15257 PyObject *resultobj = 0;
15258 PLFLT **arg1 = (PLFLT **) 0 ;
15259 PLINT arg2 ;
15260 PLINT arg3 ;
15261 PLFLT *arg4 = (PLFLT *) 0 ;
15262 PLFLT *arg5 = (PLFLT *) 0 ;
15263 PyArrayObject *tmp1 = NULL ;
15264 PLFLT temp4 ;
15265 int res4 = SWIG_TMPOBJ ;
15266 PLFLT temp5 ;
15267 int res5 = SWIG_TMPOBJ ;
15268 PyObject *swig_obj[1] ;
15269
15270 arg4 = &temp4;
15271 arg5 = &temp5;
15272 (void)self;
15273 if (!args) SWIG_fail;
15274 swig_obj[0] = args;
15275 {
15276 int i, size;
15277 tmp1 = (PyArrayObject *) myArray_ContiguousFromObject( swig_obj[0], NPY_PLFLT, 2, 2 );
15278 if ( tmp1 == NULL )
15279 return NULL;
15280 Xlen = arg2 = PyArray_DIMS( tmp1 )[0];
15281 Ylen = arg3 = PyArray_DIMS( tmp1 )[1];
15282 size = arg3;
15283 arg1 = (PLFLT **) malloc( sizeof ( PLFLT* ) * (size_t) arg2 );
15284 for ( i = 0; i < arg2; i++ )
15285 arg1[i] = ( (PLFLT *) PyArray_DATA( tmp1 ) + i * size );
15286 }
15287 plMinMax2dGrid((double const **)arg1,arg2,arg3,arg4,arg5);
15288 resultobj = SWIG_Py_Void();
15289 if (SWIG_IsTmpObj(res4)) {
15290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)), 1);
15291 } else {
15292 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags), 1);
15294 }
15295 if (SWIG_IsTmpObj(res5)) {
15296 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 1);
15297 } else {
15298 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 1);
15300 }
15301 {
15302 Py_CLEAR( tmp1 );
15303 free( arg1 );
15304 }
15305 return resultobj;
15306fail:
15307 {
15308 Py_CLEAR( tmp1 );
15309 free( arg1 );
15310 }
15311 return NULL;
15312}
15313
15314
15315SWIGINTERN PyObject *_wrap_plGetCursor(PyObject *self, PyObject *args) {
15316 PyObject *resultobj = 0;
15317 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15318 void *argp1 = 0 ;
15319 int res1 = 0 ;
15320 PyObject *swig_obj[1] ;
15321 PLINT result;
15322
15323 (void)self;
15324 if (!args) SWIG_fail;
15325 swig_obj[0] = args;
15326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15327 if (!SWIG_IsOK(res1)) {
15328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plGetCursor" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15329 }
15330 arg1 = (PLGraphicsIn *)(argp1);
15331 result = (PLINT)plGetCursor(arg1);
15332 resultobj = SWIG_From_int((int)(result));
15333 return resultobj;
15334fail:
15335 return NULL;
15336}
15337
15338
15339static PyMethodDef SwigMethods[] = {
15340 { "pltr0", _wrap_pltr0, METH_VARARGS, NULL},
15341 { "pltr1", _wrap_pltr1, METH_VARARGS, NULL},
15342 { "pltr2", _wrap_pltr2, METH_VARARGS, NULL},
15343 { "PLGraphicsIn_type_set", _wrap_PLGraphicsIn_type_set, METH_VARARGS, NULL},
15344 { "PLGraphicsIn_type_get", _wrap_PLGraphicsIn_type_get, METH_O, NULL},
15345 { "PLGraphicsIn_state_set", _wrap_PLGraphicsIn_state_set, METH_VARARGS, NULL},
15346 { "PLGraphicsIn_state_get", _wrap_PLGraphicsIn_state_get, METH_O, NULL},
15347 { "PLGraphicsIn_keysym_set", _wrap_PLGraphicsIn_keysym_set, METH_VARARGS, NULL},
15348 { "PLGraphicsIn_keysym_get", _wrap_PLGraphicsIn_keysym_get, METH_O, NULL},
15349 { "PLGraphicsIn_button_set", _wrap_PLGraphicsIn_button_set, METH_VARARGS, NULL},
15350 { "PLGraphicsIn_button_get", _wrap_PLGraphicsIn_button_get, METH_O, NULL},
15351 { "PLGraphicsIn_subwindow_set", _wrap_PLGraphicsIn_subwindow_set, METH_VARARGS, NULL},
15352 { "PLGraphicsIn_subwindow_get", _wrap_PLGraphicsIn_subwindow_get, METH_O, NULL},
15353 { "PLGraphicsIn_string_set", _wrap_PLGraphicsIn_string_set, METH_VARARGS, NULL},
15354 { "PLGraphicsIn_string_get", _wrap_PLGraphicsIn_string_get, METH_O, NULL},
15355 { "PLGraphicsIn_pX_set", _wrap_PLGraphicsIn_pX_set, METH_VARARGS, NULL},
15356 { "PLGraphicsIn_pX_get", _wrap_PLGraphicsIn_pX_get, METH_O, NULL},
15357 { "PLGraphicsIn_pY_set", _wrap_PLGraphicsIn_pY_set, METH_VARARGS, NULL},
15358 { "PLGraphicsIn_pY_get", _wrap_PLGraphicsIn_pY_get, METH_O, NULL},
15359 { "PLGraphicsIn_dX_set", _wrap_PLGraphicsIn_dX_set, METH_VARARGS, NULL},
15360 { "PLGraphicsIn_dX_get", _wrap_PLGraphicsIn_dX_get, METH_O, NULL},
15361 { "PLGraphicsIn_dY_set", _wrap_PLGraphicsIn_dY_set, METH_VARARGS, NULL},
15362 { "PLGraphicsIn_dY_get", _wrap_PLGraphicsIn_dY_get, METH_O, NULL},
15363 { "PLGraphicsIn_wX_set", _wrap_PLGraphicsIn_wX_set, METH_VARARGS, NULL},
15364 { "PLGraphicsIn_wX_get", _wrap_PLGraphicsIn_wX_get, METH_O, NULL},
15365 { "PLGraphicsIn_wY_set", _wrap_PLGraphicsIn_wY_set, METH_VARARGS, NULL},
15366 { "PLGraphicsIn_wY_get", _wrap_PLGraphicsIn_wY_get, METH_O, NULL},
15367 { "new_PLGraphicsIn", _wrap_new_PLGraphicsIn, METH_NOARGS, NULL},
15368 { "delete_PLGraphicsIn", _wrap_delete_PLGraphicsIn, METH_O, NULL},
15369 { "PLGraphicsIn_swigregister", PLGraphicsIn_swigregister, METH_O, NULL},
15370 { "PLGraphicsIn_swiginit", PLGraphicsIn_swiginit, METH_VARARGS, NULL},
15371 { "plsxwin", _wrap_plsxwin, METH_O, NULL},
15372 { "pl_setcontlabelformat", _wrap_pl_setcontlabelformat, METH_VARARGS, "\n"
15373 "Set format of numerical label for contours\n"
15374 "\n"
15375 "DESCRIPTION:\n"
15376 "\n"
15377 " Set format of numerical label for contours.\n"
15378 "\n"
15379 " Redacted form: pl_setcontlabelformat(lexp, sigdig)\n"
15380 "\n"
15381 " This function is used example 9.\n"
15382 "\n"
15383 "\n"
15384 "\n"
15385 "SYNOPSIS:\n"
15386 "\n"
15387 "pl_setcontlabelformat(lexp, sigdig)\n"
15388 "\n"
15389 "ARGUMENTS:\n"
15390 "\n"
15391 " lexp (PLINT, input) : If the contour numerical label is greater\n"
15392 " than 10^(lexp) or less than 10^(-lexp), then the exponential\n"
15393 " format is used. Default value of lexp is 4.\n"
15394 "\n"
15395 " sigdig (PLINT, input) : Number of significant digits. Default\n"
15396 " value is 2.\n"
15397 "\n"
15398 ""},
15399 { "pl_setcontlabelparam", _wrap_pl_setcontlabelparam, METH_VARARGS, "\n"
15400 "Set parameters of contour labelling other than format of numerical label\n"
15401 "\n"
15402 "DESCRIPTION:\n"
15403 "\n"
15404 " Set parameters of contour labelling other than those handled by\n"
15405 " pl_setcontlabelformat.\n"
15406 "\n"
15407 " Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n"
15408 "\n"
15409 " This function is used in example 9.\n"
15410 "\n"
15411 "\n"
15412 "\n"
15413 "SYNOPSIS:\n"
15414 "\n"
15415 "pl_setcontlabelparam(offset, size, spacing, active)\n"
15416 "\n"
15417 "ARGUMENTS:\n"
15418 "\n"
15419 " offset (PLFLT, input) : Offset of label from contour line (if set\n"
15420 " to 0.0, labels are printed on the lines). Default value is 0.006.\n"
15421 "\n"
15422 " size (PLFLT, input) : Font height for contour labels (normalized).\n"
15423 " Default value is 0.3.\n"
15424 "\n"
15425 " spacing (PLFLT, input) : Spacing parameter for contour labels.\n"
15426 " Default value is 0.1.\n"
15427 "\n"
15428 " active (PLINT, input) : Activate labels. Set to 1 if you want\n"
15429 " contour labels on. Default is off (0).\n"
15430 "\n"
15431 ""},
15432 { "pladv", _wrap_pladv, METH_O, "\n"
15433 "Advance the (sub-)page\n"
15434 "\n"
15435 "DESCRIPTION:\n"
15436 "\n"
15437 " Advances to the next subpage if sub=0, performing a page advance if\n"
15438 " there are no remaining subpages on the current page. If subpages\n"
15439 " aren't being used, pladv(0) will always advance the page. If page>0,\n"
15440 " PLplot switches to the specified subpage. Note that this allows you\n"
15441 " to overwrite a plot on the specified subpage; if this is not what you\n"
15442 " intended, use pleop followed by plbop to first advance the page. This\n"
15443 " routine is called automatically (with page=0) by plenv, but if plenv\n"
15444 " is not used, pladv must be called after initializing PLplot but before\n"
15445 " defining the viewport.\n"
15446 "\n"
15447 " Redacted form: pladv(page)\n"
15448 "\n"
15449 " This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n"
15450 " 29, and 31.\n"
15451 "\n"
15452 "\n"
15453 "\n"
15454 "SYNOPSIS:\n"
15455 "\n"
15456 "pladv(page)\n"
15457 "\n"
15458 "ARGUMENTS:\n"
15459 "\n"
15460 " page (PLINT, input) : Specifies the subpage number (starting from 1\n"
15461 " in the top left corner and increasing along the rows) to which to\n"
15462 " advance. Set to zero to advance to the next subpage (or to the\n"
15463 " next page if subpages are not being used).\n"
15464 "\n"
15465 ""},
15466 { "plarc", _wrap_plarc, METH_VARARGS, "\n"
15467 "Draw a circular or elliptical arc\n"
15468 "\n"
15469 "DESCRIPTION:\n"
15470 "\n"
15471 " Draw a possibly filled arc centered at x, y with semimajor axis a and\n"
15472 " semiminor axis b, starting at angle1 and ending at angle2.\n"
15473 "\n"
15474 " Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n"
15475 " fill)\n"
15476 "\n"
15477 "\n"
15478 " This function is used in examples 3 and 27.\n"
15479 "\n"
15480 "\n"
15481 "\n"
15482 "SYNOPSIS:\n"
15483 "\n"
15484 "plarc(x, y, a, b, angle1, angle2, rotate, fill)\n"
15485 "\n"
15486 "ARGUMENTS:\n"
15487 "\n"
15488 " x (PLFLT, input) : X coordinate of arc center.\n"
15489 "\n"
15490 " y (PLFLT, input) : Y coordinate of arc center.\n"
15491 "\n"
15492 " a (PLFLT, input) : Length of the semimajor axis of the arc.\n"
15493 "\n"
15494 " b (PLFLT, input) : Length of the semiminor axis of the arc.\n"
15495 "\n"
15496 " angle1 (PLFLT, input) : Starting angle of the arc relative to the\n"
15497 " semimajor axis.\n"
15498 "\n"
15499 " angle2 (PLFLT, input) : Ending angle of the arc relative to the\n"
15500 " semimajor axis.\n"
15501 "\n"
15502 " rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n"
15503 " X-axis.\n"
15504 "\n"
15505 " fill (PLBOOL, input) : Draw a filled arc.\n"
15506 "\n"
15507 ""},
15508 { "plaxes", _wrap_plaxes, METH_VARARGS, "\n"
15509 "Draw a box with axes, etc. with arbitrary origin\n"
15510 "\n"
15511 "DESCRIPTION:\n"
15512 "\n"
15513 " Draws a box around the currently defined viewport with arbitrary\n"
15514 " world-coordinate origin specified by x0 and y0 and labels it with\n"
15515 " world coordinate values appropriate to the window. Thus plaxes should\n"
15516 " only be called after defining both viewport and window. The ascii\n"
15517 " character strings xopt and yopt specify how the box should be drawn as\n"
15518 " described below. If ticks and/or subticks are to be drawn for a\n"
15519 " particular axis, the tick intervals and number of subintervals may be\n"
15520 " specified explicitly, or they may be defaulted by setting the\n"
15521 " appropriate arguments to zero.\n"
15522 "\n"
15523 " Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n"
15524 " ytick, nysub)\n"
15525 "\n"
15526 "\n"
15527 " This function is not used in any examples.\n"
15528 "\n"
15529 "\n"
15530 "\n"
15531 "SYNOPSIS:\n"
15532 "\n"
15533 "plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15534 "\n"
15535 "ARGUMENTS:\n"
15536 "\n"
15537 " x0 (PLFLT, input) : World X coordinate of origin.\n"
15538 "\n"
15539 " y0 (PLFLT, input) : World Y coordinate of origin.\n"
15540 "\n"
15541 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15542 " options for the x axis. The string can include any combination of\n"
15543 " the following letters (upper or lower case) in any order: a: Draws\n"
15544 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15545 " (x=0).\n"
15546 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15547 " c: Draws top (X) or right (Y) edge of frame.\n"
15548 " d: Plot labels as date / time. Values are assumed to be\n"
15549 " seconds since the epoch (as used by gmtime).\n"
15550 " f: Always use fixed point numeric labels.\n"
15551 " g: Draws a grid at the major tick interval.\n"
15552 " h: Draws a grid at the minor tick interval.\n"
15553 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15554 " inwards.\n"
15555 " l: Labels axis logarithmically. This only affects the labels,\n"
15556 " not the data, and so it is necessary to compute the logarithms\n"
15557 " of data points before passing them to any of the drawing\n"
15558 " routines.\n"
15559 " m: Writes numeric labels at major tick intervals in the\n"
15560 " unconventional location (above box for X, right of box for Y).\n"
15561 " n: Writes numeric labels at major tick intervals in the\n"
15562 " conventional location (below box for X, left of box for Y).\n"
15563 " o: Use custom labelling function to generate axis label text.\n"
15564 " The custom labelling function can be defined with the\n"
15565 " plslabelfunc command.\n"
15566 " s: Enables subticks between major ticks, only valid if t is\n"
15567 " also specified.\n"
15568 " t: Draws major ticks.\n"
15569 " u: Exactly like \"b\" except don't draw edge line.\n"
15570 " w: Exactly like \"c\" except don't draw edge line.\n"
15571 " x: Exactly like \"t\" (including the side effect of the\n"
15572 " numerical labels for the major ticks) except exclude drawing\n"
15573 " the major and minor tick marks.\n"
15574 "\n"
15575 "\n"
15576 " xtick (PLFLT, input) : World coordinate interval between major\n"
15577 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15578 " generates a suitable tick interval.\n"
15579 "\n"
15580 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15581 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15582 " generates a suitable minor tick interval.\n"
15583 "\n"
15584 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15585 " options for the y axis. The string can include any combination of\n"
15586 " the letters defined above for xopt, and in addition may contain:\n"
15587 " v: Write numeric labels for the y axis parallel to the base of the\n"
15588 " graph, rather than parallel to the axis.\n"
15589 "\n"
15590 "\n"
15591 " ytick (PLFLT, input) : World coordinate interval between major\n"
15592 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15593 " generates a suitable tick interval.\n"
15594 "\n"
15595 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15596 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15597 " generates a suitable minor tick interval.\n"
15598 "\n"
15599 ""},
15600 { "plbin", _wrap_plbin, METH_VARARGS, "\n"
15601 "Plot a histogram from binned data\n"
15602 "\n"
15603 "DESCRIPTION:\n"
15604 "\n"
15605 " Plots a histogram consisting of nbin bins. The value associated with\n"
15606 " the i'th bin is placed in x[i], and the number of points in the bin is\n"
15607 " placed in y[i]. For proper operation, the values in x[i] must form a\n"
15608 " strictly increasing sequence. By default, x[i] is the left-hand edge\n"
15609 " of the i'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n"
15610 " placed midway between the values in the x vector. Also see plhist for\n"
15611 " drawing histograms from unbinned data.\n"
15612 "\n"
15613 " Redacted form: General: plbin(x, y, opt)\n"
15614 " Python: plbin(nbin, x, y, opt)\n"
15615 "\n"
15616 "\n"
15617 " This function is not used in any examples.\n"
15618 "\n"
15619 "\n"
15620 "\n"
15621 "SYNOPSIS:\n"
15622 "\n"
15623 "plbin(nbin, x, y, opt)\n"
15624 "\n"
15625 "ARGUMENTS:\n"
15626 "\n"
15627 " nbin (PLINT, input) : Number of bins (i.e., number of values in x\n"
15628 " and y vectors.)\n"
15629 "\n"
15630 " x (PLFLT_VECTOR, input) : A vector containing values associated\n"
15631 " with bins. These must form a strictly increasing sequence.\n"
15632 "\n"
15633 " y (PLFLT_VECTOR, input) : A vector containing a number which is\n"
15634 " proportional to the number of points in each bin. This is a PLFLT\n"
15635 " (instead of PLINT) vector so as to allow histograms of\n"
15636 " probabilities, etc.\n"
15637 "\n"
15638 " opt (PLINT, input) : Is a combination of several flags:\n"
15639 " opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n"
15640 " outer bins are expanded to fill up the entire x-axis and bins of\n"
15641 " zero height are simply drawn.\n"
15642 " opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n"
15643 " between the x values. If the values in x are equally spaced,\n"
15644 " the values are the center values of the bins.\n"
15645 " opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n"
15646 " size as the ones inside.\n"
15647 " opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n"
15648 " (there is a gap for such bins).\n"
15649 "\n"
15650 ""},
15651 { "plbtime", _wrap_plbtime, METH_O, "\n"
15652 "Calculate broken-down time from continuous time for the current stream\n"
15653 "\n"
15654 "DESCRIPTION:\n"
15655 "\n"
15656 " Calculate broken-down time; year, month, day, hour, min, sec; from\n"
15657 " continuous time, ctime for the current stream. This function is the\n"
15658 " inverse of plctime.\n"
15659 "\n"
15660 " The PLplot definition of broken-down time is a calendar time that\n"
15661 " completely ignores all time zone offsets, i.e., it is the user's\n"
15662 " responsibility to apply those offsets (if so desired) before using the\n"
15663 " PLplot time API. By default broken-down time is defined using the\n"
15664 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
15665 " continuous time is defined as the number of seconds since the Unix\n"
15666 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
15667 " broken-down and continuous time are possible, see plconfigtime.\n"
15668 "\n"
15669 " Redacted form: General: plbtime(year, month, day, hour, min, sec,\n"
15670 " ctime)\n"
15671 "\n"
15672 "\n"
15673 " This function is used in example 29.\n"
15674 "\n"
15675 "\n"
15676 "\n"
15677 "SYNOPSIS:\n"
15678 "\n"
15679 "plbtime(year, month, day, hour, min, sec, ctime)\n"
15680 "\n"
15681 "ARGUMENTS:\n"
15682 "\n"
15683 " year (PLINT_NC_SCALAR, output) : Returned value of years with\n"
15684 " positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n"
15685 " non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n"
15686 " BCE, etc.)\n"
15687 "\n"
15688 " month (PLINT_NC_SCALAR, output) : Returned value of month within\n"
15689 " the year in the range from 0 (January) to 11 (December).\n"
15690 "\n"
15691 " day (PLINT_NC_SCALAR, output) : Returned value of day within the\n"
15692 " month in the range from 1 to 31.\n"
15693 "\n"
15694 " hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n"
15695 " day in the range from 0 to 23.\n"
15696 "\n"
15697 " min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n"
15698 " hour in the range from 0 to 59\n"
15699 "\n"
15700 " sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n"
15701 " minute in range from 0. to 60.\n"
15702 "\n"
15703 " ctime (PLFLT, input) : Continuous time from which the broken-down\n"
15704 " time is calculated.\n"
15705 "\n"
15706 ""},
15707 { "plbop", _wrap_plbop, METH_NOARGS, "\n"
15708 "Begin a new page\n"
15709 "\n"
15710 "DESCRIPTION:\n"
15711 "\n"
15712 " Begins a new page. For a file driver, the output file is opened if\n"
15713 " necessary. Advancing the page via pleop and plbop is useful when a\n"
15714 " page break is desired at a particular point when plotting to subpages.\n"
15715 " Another use for pleop and plbop is when plotting pages to different\n"
15716 " files, since you can manually set the file name by calling plsfnam\n"
15717 " after the call to pleop. (In fact some drivers may only support a\n"
15718 " single page per file, making this a necessity.) One way to handle\n"
15719 " this case automatically is to page advance via pladv, but enable\n"
15720 " familying (see plsfam) with a small limit on the file size so that a\n"
15721 " new family member file will be created on each page break.\n"
15722 "\n"
15723 " Redacted form: plbop()\n"
15724 "\n"
15725 " This function is used in examples 2 and 20.\n"
15726 "\n"
15727 "\n"
15728 "\n"
15729 "SYNOPSIS:\n"
15730 "\n"
15731 "plbop()\n"
15732 "\n"
15733 ""},
15734 { "plbox", _wrap_plbox, METH_VARARGS, "\n"
15735 "Draw a box with axes, etc\n"
15736 "\n"
15737 "DESCRIPTION:\n"
15738 "\n"
15739 " Draws a box around the currently defined viewport, and labels it with\n"
15740 " world coordinate values appropriate to the window. Thus plbox should\n"
15741 " only be called after defining both viewport and window. The ascii\n"
15742 " character strings xopt and yopt specify how the box should be drawn as\n"
15743 " described below. If ticks and/or subticks are to be drawn for a\n"
15744 " particular axis, the tick intervals and number of subintervals may be\n"
15745 " specified explicitly, or they may be defaulted by setting the\n"
15746 " appropriate arguments to zero.\n"
15747 "\n"
15748 " Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15749 "\n"
15750 "\n"
15751 " This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n"
15752 " and 29.\n"
15753 "\n"
15754 "\n"
15755 "\n"
15756 "SYNOPSIS:\n"
15757 "\n"
15758 "plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n"
15759 "\n"
15760 "ARGUMENTS:\n"
15761 "\n"
15762 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15763 " options for the x axis. The string can include any combination of\n"
15764 " the following letters (upper or lower case) in any order: a: Draws\n"
15765 " axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n"
15766 " (x=0).\n"
15767 " b: Draws bottom (X) or left (Y) edge of frame.\n"
15768 " c: Draws top (X) or right (Y) edge of frame.\n"
15769 " d: Plot labels as date / time. Values are assumed to be\n"
15770 " seconds since the epoch (as used by gmtime).\n"
15771 " f: Always use fixed point numeric labels.\n"
15772 " g: Draws a grid at the major tick interval.\n"
15773 " h: Draws a grid at the minor tick interval.\n"
15774 " i: Inverts tick marks, so they are drawn outwards, rather than\n"
15775 " inwards.\n"
15776 " l: Labels axis logarithmically. This only affects the labels,\n"
15777 " not the data, and so it is necessary to compute the logarithms\n"
15778 " of data points before passing them to any of the drawing\n"
15779 " routines.\n"
15780 " m: Writes numeric labels at major tick intervals in the\n"
15781 " unconventional location (above box for X, right of box for Y).\n"
15782 " n: Writes numeric labels at major tick intervals in the\n"
15783 " conventional location (below box for X, left of box for Y).\n"
15784 " o: Use custom labelling function to generate axis label text.\n"
15785 " The custom labelling function can be defined with the\n"
15786 " plslabelfunc command.\n"
15787 " s: Enables subticks between major ticks, only valid if t is\n"
15788 " also specified.\n"
15789 " t: Draws major ticks.\n"
15790 " u: Exactly like \"b\" except don't draw edge line.\n"
15791 " w: Exactly like \"c\" except don't draw edge line.\n"
15792 " x: Exactly like \"t\" (including the side effect of the\n"
15793 " numerical labels for the major ticks) except exclude drawing\n"
15794 " the major and minor tick marks.\n"
15795 "\n"
15796 "\n"
15797 " xtick (PLFLT, input) : World coordinate interval between major\n"
15798 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15799 " generates a suitable tick interval.\n"
15800 "\n"
15801 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15802 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15803 " generates a suitable minor tick interval.\n"
15804 "\n"
15805 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15806 " options for the y axis. The string can include any combination of\n"
15807 " the letters defined above for xopt, and in addition may contain:\n"
15808 " v: Write numeric labels for the y axis parallel to the base of the\n"
15809 " graph, rather than parallel to the axis.\n"
15810 "\n"
15811 "\n"
15812 " ytick (PLFLT, input) : World coordinate interval between major\n"
15813 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15814 " generates a suitable tick interval.\n"
15815 "\n"
15816 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15817 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15818 " generates a suitable minor tick interval.\n"
15819 "\n"
15820 ""},
15821 { "plbox3", _wrap_plbox3, METH_VARARGS, "\n"
15822 "Draw a box with axes, etc, in 3-d\n"
15823 "\n"
15824 "DESCRIPTION:\n"
15825 "\n"
15826 " Draws axes, numeric and text labels for a three-dimensional surface\n"
15827 " plot. For a more complete description of three-dimensional plotting\n"
15828 " see the PLplot documentation.\n"
15829 "\n"
15830 " Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n"
15831 " ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15832 "\n"
15833 "\n"
15834 " This function is used in examples 8, 11, 18, and 21.\n"
15835 "\n"
15836 "\n"
15837 "\n"
15838 "SYNOPSIS:\n"
15839 "\n"
15840 "plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n"
15841 "\n"
15842 "ARGUMENTS:\n"
15843 "\n"
15844 " xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15845 " options for the x axis. The string can include any combination of\n"
15846 " the following letters (upper or lower case) in any order: b: Draws\n"
15847 " axis at base, at height z=\n"
15848 " zmin where zmin is defined by call to plw3d. This character must be\n"
15849 " specified in order to use any of the other options.\n"
15850 " d: Plot labels as date / time. Values are assumed to be\n"
15851 " seconds since the epoch (as used by gmtime).\n"
15852 " f: Always use fixed point numeric labels.\n"
15853 " i: Inverts tick marks, so they are drawn downwards, rather\n"
15854 " than upwards.\n"
15855 " l: Labels axis logarithmically. This only affects the labels,\n"
15856 " not the data, and so it is necessary to compute the logarithms\n"
15857 " of data points before passing them to any of the drawing\n"
15858 " routines.\n"
15859 " n: Writes numeric labels at major tick intervals.\n"
15860 " o: Use custom labelling function to generate axis label text.\n"
15861 " The custom labelling function can be defined with the\n"
15862 " plslabelfunc command.\n"
15863 " s: Enables subticks between major ticks, only valid if t is\n"
15864 " also specified.\n"
15865 " t: Draws major ticks.\n"
15866 " u: If this is specified, the text label for the axis is\n"
15867 " written under the axis.\n"
15868 "\n"
15869 "\n"
15870 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15871 " the text label for the x axis. It is only drawn if u is in the\n"
15872 " xopt string.\n"
15873 "\n"
15874 " xtick (PLFLT, input) : World coordinate interval between major\n"
15875 " ticks on the x axis. If it is set to zero, PLplot automatically\n"
15876 " generates a suitable tick interval.\n"
15877 "\n"
15878 " nxsub (PLINT, input) : Number of subintervals between major x axis\n"
15879 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15880 " generates a suitable minor tick interval.\n"
15881 "\n"
15882 " yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15883 " options for the y axis. The string is interpreted in the same way\n"
15884 " as xopt.\n"
15885 "\n"
15886 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15887 " the text label for the y axis. It is only drawn if u is in the\n"
15888 " yopt string.\n"
15889 "\n"
15890 " ytick (PLFLT, input) : World coordinate interval between major\n"
15891 " ticks on the y axis. If it is set to zero, PLplot automatically\n"
15892 " generates a suitable tick interval.\n"
15893 "\n"
15894 " nysub (PLINT, input) : Number of subintervals between major y axis\n"
15895 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15896 " generates a suitable minor tick interval.\n"
15897 "\n"
15898 " zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
15899 " options for the z axis. The string can include any combination of\n"
15900 " the following letters (upper or lower case) in any order: b: Draws\n"
15901 " z axis to the left of the surface plot.\n"
15902 " c: Draws z axis to the right of the surface plot.\n"
15903 " d: Draws grid lines parallel to the x-y plane behind the\n"
15904 " figure. These lines are not drawn until after plot3d or\n"
15905 " plmesh are called because of the need for hidden line removal.\n"
15906 " e: Plot labels as date / time. Values are assumed to be\n"
15907 " seconds since the epoch (as used by gmtime). Note this\n"
15908 " suboption is interpreted the same as the d suboption for xopt\n"
15909 " and yopt, but it has to be identified as e for zopt since d\n"
15910 " has already been used for the different purpose above.\n"
15911 " f: Always use fixed point numeric labels.\n"
15912 " i: Inverts tick marks, so they are drawn away from the center.\n"
15913 " l: Labels axis logarithmically. This only affects the labels,\n"
15914 " not the data, and so it is necessary to compute the logarithms\n"
15915 " of data points before passing them to any of the drawing\n"
15916 " routines.\n"
15917 " m: Writes numeric labels at major tick intervals on the\n"
15918 " right-hand z axis.\n"
15919 " n: Writes numeric labels at major tick intervals on the\n"
15920 " left-hand z axis.\n"
15921 " o: Use custom labelling function to generate axis label text.\n"
15922 " The custom labelling function can be defined with the\n"
15923 " plslabelfunc command.\n"
15924 " s: Enables subticks between major ticks, only valid if t is\n"
15925 " also specified.\n"
15926 " t: Draws major ticks.\n"
15927 " u: If this is specified, the text label is written beside the\n"
15928 " left-hand axis.\n"
15929 " v: If this is specified, the text label is written beside the\n"
15930 " right-hand axis.\n"
15931 "\n"
15932 "\n"
15933 " zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
15934 " the text label for the z axis. It is only drawn if u or v are in\n"
15935 " the zopt string.\n"
15936 "\n"
15937 " ztick (PLFLT, input) : World coordinate interval between major\n"
15938 " ticks on the z axis. If it is set to zero, PLplot automatically\n"
15939 " generates a suitable tick interval.\n"
15940 "\n"
15941 " nzsub (PLINT, input) : Number of subintervals between major z axis\n"
15942 " ticks for minor ticks. If it is set to zero, PLplot automatically\n"
15943 " generates a suitable minor tick interval.\n"
15944 "\n"
15945 ""},
15946 { "plcalc_world", _wrap_plcalc_world, METH_VARARGS, "\n"
15947 "Calculate world coordinates and corresponding window index from relative device coordinates\n"
15948 "\n"
15949 "DESCRIPTION:\n"
15950 "\n"
15951 " Calculate world coordinates, wx and wy, and corresponding window index\n"
15952 " from relative device coordinates, rx and ry.\n"
15953 "\n"
15954 " Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n"
15955 "\n"
15956 "\n"
15957 " This function is used in example 31.\n"
15958 "\n"
15959 "\n"
15960 "\n"
15961 "SYNOPSIS:\n"
15962 "\n"
15963 "plcalc_world(rx, ry, wx, wy, window)\n"
15964 "\n"
15965 "ARGUMENTS:\n"
15966 "\n"
15967 " rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15968 " the x coordinate.\n"
15969 "\n"
15970 " ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n"
15971 " the y coordinate.\n"
15972 "\n"
15973 " wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n"
15974 " coordinate corresponding to the relative device coordinates rx and\n"
15975 " ry.\n"
15976 "\n"
15977 " wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n"
15978 " coordinate corresponding to the relative device coordinates rx and\n"
15979 " ry.\n"
15980 "\n"
15981 " window (PLINT_NC_SCALAR, output) : Returned value of the last\n"
15982 " defined window index that corresponds to the input relative device\n"
15983 " coordinates (and the returned world coordinates). To give some\n"
15984 " background on the window index, for each page the initial window\n"
15985 " index is set to zero, and each time plwind is called within the\n"
15986 " page, world and device coordinates are stored for the window and\n"
15987 " the window index is incremented. Thus, for a simple page layout\n"
15988 " with non-overlapping viewports and one window per viewport, window\n"
15989 " corresponds to the viewport index (in the order which the\n"
15990 " viewport/windows were created) of the only viewport/window\n"
15991 " corresponding to rx and ry. However, for more complicated layouts\n"
15992 " with potentially overlapping viewports and possibly more than one\n"
15993 " window (set of world coordinates) per viewport, window and the\n"
15994 " corresponding output world coordinates corresponds to the last\n"
15995 " window created that fulfills the criterion that the relative\n"
15996 " device coordinates are inside it. Finally, in all cases where the\n"
15997 " input relative device coordinates are not inside any\n"
15998 " viewport/window, then the returned value of the last defined\n"
15999 " window index is set to -1.\n"
16000 "\n"
16001 ""},
16002 { "plclear", _wrap_plclear, METH_NOARGS, "\n"
16003 "Clear current (sub)page\n"
16004 "\n"
16005 "DESCRIPTION:\n"
16006 "\n"
16007 " Clears the current page, effectively erasing everything that have been\n"
16008 " drawn. This command only works with interactive drivers; if the\n"
16009 " driver does not support this, the page is filled with the background\n"
16010 " color in use. If the current page is divided into subpages, only the\n"
16011 " current subpage is erased. The nth subpage can be selected with\n"
16012 " pladv(n).\n"
16013 "\n"
16014 " Redacted form: General: plclear()\n"
16015 "\n"
16016 "\n"
16017 " This function is not used in any examples.\n"
16018 "\n"
16019 "\n"
16020 "\n"
16021 "SYNOPSIS:\n"
16022 "\n"
16023 "plclear()\n"
16024 "\n"
16025 ""},
16026 { "plcol0", _wrap_plcol0, METH_O, "\n"
16027 "Set color, cmap0\n"
16028 "\n"
16029 "DESCRIPTION:\n"
16030 "\n"
16031 " Sets the color index for cmap0 (see the PLplot documentation).\n"
16032 "\n"
16033 " Redacted form: plcol0(icol0)\n"
16034 "\n"
16035 " This function is used in examples 1-9, 11-16, 18-27, and 29.\n"
16036 "\n"
16037 "\n"
16038 "\n"
16039 "SYNOPSIS:\n"
16040 "\n"
16041 "plcol0(icol0)\n"
16042 "\n"
16043 "ARGUMENTS:\n"
16044 "\n"
16045 " icol0 (PLINT, input) : Integer representing the color. The\n"
16046 " defaults at present are (these may change):\n"
16047 " 0 black (default background)\n"
16048 " 1 red (default foreground)\n"
16049 " 2 yellow\n"
16050 " 3 green\n"
16051 " 4 aquamarine\n"
16052 " 5 pink\n"
16053 " 6 wheat\n"
16054 " 7 grey\n"
16055 " 8 brown\n"
16056 " 9 blue\n"
16057 " 10 BlueViolet\n"
16058 " 11 cyan\n"
16059 " 12 turquoise\n"
16060 " 13 magenta\n"
16061 " 14 salmon\n"
16062 " 15 white\n"
16063 "\n"
16064 " Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n"
16065 " change an individual color in the cmap0 color palette.\n"
16066 "\n"
16067 ""},
16068 { "plcol1", _wrap_plcol1, METH_O, "\n"
16069 "Set color, cmap1\n"
16070 "\n"
16071 "DESCRIPTION:\n"
16072 "\n"
16073 " Sets the color for cmap1 (see the PLplot documentation).\n"
16074 "\n"
16075 " Redacted form: plcol1(col1)\n"
16076 "\n"
16077 " This function is used in examples 12 and 21.\n"
16078 "\n"
16079 "\n"
16080 "\n"
16081 "SYNOPSIS:\n"
16082 "\n"
16083 "plcol1(col1)\n"
16084 "\n"
16085 "ARGUMENTS:\n"
16086 "\n"
16087 " col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n"
16088 " is mapped to color using the continuous cmap1 palette which by\n"
16089 " default ranges from blue to the background color to red. The\n"
16090 " cmap1 palette can also be straightforwardly changed by the user\n"
16091 " with plscmap1 or plscmap1l.\n"
16092 "\n"
16093 ""},
16094 { "plconfigtime", _wrap_plconfigtime, METH_VARARGS, "\n"
16095 "Configure the transformation between continuous and broken-down time for the current stream\n"
16096 "\n"
16097 "DESCRIPTION:\n"
16098 "\n"
16099 " Configure the transformation between continuous and broken-down time\n"
16100 " for the current stream. This transformation is used by both plbtime\n"
16101 " and plctime.\n"
16102 "\n"
16103 " Redacted form: General: plconfigtime(scale, offset1, offset2,\n"
16104 " ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16105 "\n"
16106 "\n"
16107 " This function is used in example 29.\n"
16108 "\n"
16109 "\n"
16110 "\n"
16111 "SYNOPSIS:\n"
16112 "\n"
16113 "plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n"
16114 "\n"
16115 "ARGUMENTS:\n"
16116 "\n"
16117 " scale (PLFLT, input) : The number of days per continuous time unit.\n"
16118 " As a special case, if\n"
16119 " scale is 0., then all other arguments are ignored, and the result (the\n"
16120 " default used by PLplot) is the equivalent of a call to\n"
16121 " plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n"
16122 " That is, for this special case broken-down time is calculated with\n"
16123 " the proleptic Gregorian calendar with no leap seconds inserted,\n"
16124 " and the continuous time is defined as the number of seconds since\n"
16125 " the Unix epoch of 1970-01-01T00:00:00Z.\n"
16126 "\n"
16127 " offset1 (PLFLT, input) : If\n"
16128 " ifbtime_offset is true, the parameters\n"
16129 " offset1 and\n"
16130 " offset2 are completely ignored. Otherwise, the sum of these parameters\n"
16131 " (with units in days) specify the epoch of the continuous time\n"
16132 " relative to the MJD epoch corresponding to the Gregorian calendar\n"
16133 " date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n"
16134 " are used to specify the origin to allow users (by specifying\n"
16135 " offset1 as an integer that can be exactly represented by a\n"
16136 " floating-point variable and specifying\n"
16137 " offset2 as a number in the range from 0. to 1) the chance to minimize\n"
16138 " the numerical errors of the continuous time representation.\n"
16139 "\n"
16140 " offset2 (PLFLT, input) : See documentation of\n"
16141 " offset1.\n"
16142 "\n"
16143 " ccontrol (PLINT, input) : ccontrol contains bits controlling the\n"
16144 " transformation. If the 0x1 bit is set, then the proleptic Julian\n"
16145 " calendar is used for broken-down time rather than the proleptic\n"
16146 " Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n"
16147 " have been historically used to define UTC are inserted into the\n"
16148 " broken-down time. Other possibilities for additional control bits\n"
16149 " for ccontrol exist such as making the historical time corrections\n"
16150 " in the broken-down time corresponding to ET (ephemeris time) or\n"
16151 " making the (slightly non-constant) corrections from international\n"
16152 " atomic time (TAI) to what astronomers define as terrestrial time\n"
16153 " (TT). But those additional possibilities have not been\n"
16154 " implemented yet in the qsastime library (one of the PLplot utility\n"
16155 " libraries).\n"
16156 "\n"
16157 " ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n"
16158 " epoch of the continuous time scale is specified by the user. If\n"
16159 " ifbtime_offset is false, then\n"
16160 " offset1 and\n"
16161 " offset2 are used to specify the epoch, and the following broken-down\n"
16162 " time parameters are completely ignored. If\n"
16163 " ifbtime_offset is true, then\n"
16164 " offset1 and\n"
16165 " offset2 are completely ignored, and the following broken-down time\n"
16166 " parameters are used to specify the epoch.\n"
16167 "\n"
16168 " year (PLINT, input) : Year of epoch.\n"
16169 "\n"
16170 " month (PLINT, input) : Month of epoch in range from 0 (January) to\n"
16171 " 11 (December).\n"
16172 "\n"
16173 " day (PLINT, input) : Day of epoch in range from 1 to 31.\n"
16174 "\n"
16175 " hour (PLINT, input) : Hour of epoch in range from 0 to 23\n"
16176 "\n"
16177 " min (PLINT, input) : Minute of epoch in range from 0 to 59.\n"
16178 "\n"
16179 " sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n"
16180 "\n"
16181 ""},
16182 { "plcont", _wrap_plcont, METH_VARARGS, "\n"
16183 "Contour plot\n"
16184 "\n"
16185 "DESCRIPTION:\n"
16186 "\n"
16187 " Draws a contour plot of the data in f[\n"
16188 " nx][\n"
16189 " ny], using the nlevel contour levels specified by clevel. Only the\n"
16190 " region of the matrix from kx to lx and from ky to ly is plotted out\n"
16191 " where all these index ranges are interpreted as one-based for\n"
16192 " historical reasons. A transformation routine pointed to by pltr with\n"
16193 " a generic pointer pltr_data for additional data required by the\n"
16194 " transformation routine is used to map indices within the matrix to the\n"
16195 " world coordinates.\n"
16196 "\n"
16197 " Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n"
16198 " where (see above discussion) the pltr, pltr_data callback arguments\n"
16199 " are sometimes replaced by a tr vector with 6 elements; xg and yg\n"
16200 " vectors; or xg and yg matrices.\n"
16201 "\n"
16202 " This function is used in examples 9, 14, 16, and 22.\n"
16203 "\n"
16204 "\n"
16205 "\n"
16206 "SYNOPSIS:\n"
16207 "\n"
16208 "plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n"
16209 "\n"
16210 "ARGUMENTS:\n"
16211 "\n"
16212 " f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n"
16213 "\n"
16214 " nx, ny (PLINT, input) : The dimensions of the matrix f.\n"
16215 "\n"
16216 " kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n"
16217 " kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n"
16218 " zero-based for historical backwards-compatibility reasons.\n"
16219 "\n"
16220 " ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n"
16221 " ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n"
16222 " zero-based for historical backwards-compatibility reasons.\n"
16223 "\n"
16224 " clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n"
16225 " which to draw contours.\n"
16226 "\n"
16227 " nlevel (PLINT, input) : Number of contour levels to draw.\n"
16228 "\n"
16229 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
16230 " defines the transformation between the zero-based indices of the\n"
16231 " matrix f and the world coordinates.For the C case, transformation\n"
16232 " functions are provided in the PLplot library: pltr0 for the\n"
16233 " identity mapping, and pltr1 and pltr2 for arbitrary mappings\n"
16234 " respectively defined by vectors and matrices. In addition, C\n"
16235 " callback routines for the transformation can be supplied by the\n"
16236 " user such as the mypltr function in examples/c/x09c.c which\n"
16237 " provides a general linear transformation between index coordinates\n"
16238 " and world coordinates.For languages other than C you should\n"
16239 " consult the PLplot documentation for the details concerning how\n"
16240 " PLTRANSFORM_callback arguments are interfaced. However, in\n"
16241 " general, a particular pattern of callback-associated arguments\n"
16242 " such as a tr vector with 6 elements; xg and yg vectors; or xg and\n"
16243 " yg matrices are respectively interfaced to a linear-transformation\n"
16244 " routine similar to the above mypltr function; pltr1; and pltr2.\n"
16245 " Furthermore, some of our more sophisticated bindings (see, e.g.,\n"
16246 " the PLplot documentation) support native language callbacks for\n"
16247 " handling index to world-coordinate transformations. Examples of\n"
16248 " these various approaches are given in examples/<language>x09*,\n"
16249 " examples/<language>x16*, examples/<language>x20*,\n"
16250 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
16251 " supported languages.\n"
16252 "\n"
16253 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
16254 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
16255 " that is externally supplied.\n"
16256 "\n"
16257 ""},
16258 { "plctime", _wrap_plctime, METH_VARARGS, "\n"
16259 "Calculate continuous time from broken-down time for the current stream\n"
16260 "\n"
16261 "DESCRIPTION:\n"
16262 "\n"
16263 " Calculate continuous time, ctime, from broken-down time for the\n"
16264 " current stream. The broken-down\n"
16265 " time is specified by the following parameters: year, month, day, hour,\n"
16266 " min, and sec. This function is the inverse of plbtime.\n"
16267 "\n"
16268 " The PLplot definition of broken-down time is a calendar time that\n"
16269 " completely ignores all time zone offsets, i.e., it is the user's\n"
16270 " responsibility to apply those offsets (if so desired) before using the\n"
16271 " PLplot time API. By default broken-down time is defined using the\n"
16272 " proleptic Gregorian calendar without the insertion of leap seconds and\n"
16273 " continuous time is defined as the number of seconds since the Unix\n"
16274 " epoch of 1970-01-01T00:00:00Z. However, other definitions of\n"
16275 " broken-down and continuous time are possible, see plconfigtime which\n"
16276 " specifies that transformation for the current stream.\n"
16277 "\n"
16278 " Redacted form: General: plctime(year, month, day, hour, min, sec,\n"
16279 " ctime)\n"
16280 "\n"
16281 "\n"
16282 " This function is used in example 29.\n"
16283 "\n"
16284 "\n"
16285 "\n"
16286 "SYNOPSIS:\n"
16287 "\n"
16288 "plctime(year, month, day, hour, min, sec, ctime)\n"
16289 "\n"
16290 "ARGUMENTS:\n"
16291 "\n"
16292 " year (PLINT, input) : Input year.\n"
16293 "\n"
16294 " month (PLINT, input) : Input month in range from 0 (January) to 11\n"
16295 " (December).\n"
16296 "\n"
16297 " day (PLINT, input) : Input day in range from 1 to 31.\n"
16298 "\n"
16299 " hour (PLINT, input) : Input hour in range from 0 to 23\n"
16300 "\n"
16301 " min (PLINT, input) : Input minute in range from 0 to 59.\n"
16302 "\n"
16303 " sec (PLFLT, input) : Input second in range from 0. to 60.\n"
16304 "\n"
16305 " ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n"
16306 " time calculated from the broken-down time specified by the\n"
16307 " previous parameters.\n"
16308 "\n"
16309 ""},
16310 { "plcpstrm", _wrap_plcpstrm, METH_VARARGS, "\n"
16311 "Copy state parameters from the reference stream to the current stream\n"
16312 "\n"
16313 "DESCRIPTION:\n"
16314 "\n"
16315 " Copies state parameters from the reference stream to the current\n"
16316 " stream. Tell driver interface to map device coordinates unless flags\n"
16317 " == 1.\n"
16318 "\n"
16319 " This function is used for making save files of selected plots (e.g.\n"
16320 " from the TK driver). After initializing, you can get a copy of the\n"
16321 " current plot to the specified device by switching to this stream and\n"
16322 " issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n"
16323 " appropriate. The plot buffer must have previously been enabled (done\n"
16324 " automatically by some display drivers, such as X).\n"
16325 "\n"
16326 " Redacted form: plcpstrm(iplsr, flags)\n"
16327 "\n"
16328 " This function is used in example 1,20.\n"
16329 "\n"
16330 "\n"
16331 "\n"
16332 "SYNOPSIS:\n"
16333 "\n"
16334 "plcpstrm(iplsr, flags)\n"
16335 "\n"
16336 "ARGUMENTS:\n"
16337 "\n"
16338 " iplsr (PLINT, input) : Number of reference stream.\n"
16339 "\n"
16340 " flags (PLBOOL, input) : If flags is set to true the device\n"
16341 " coordinates are not copied from the reference to current stream.\n"
16342 "\n"
16343 ""},
16344 { "plend", _wrap_plend, METH_NOARGS, "\n"
16345 "End plotting session\n"
16346 "\n"
16347 "DESCRIPTION:\n"
16348 "\n"
16349 " Ends a plotting session, tidies up all the output files, switches\n"
16350 " interactive devices back into text mode and frees up any memory that\n"
16351 " was allocated. Must be called before end of program.\n"
16352 "\n"
16353 " By default, PLplot's interactive devices (Xwin, TK, etc.) go into a\n"
16354 " wait state after a call to plend or other functions which trigger the\n"
16355 " end of a plot page. To avoid this, use the plspause function.\n"
16356 "\n"
16357 " Redacted form: plend()\n"
16358 "\n"
16359 " This function is used in all of the examples.\n"
16360 "\n"
16361 "\n"
16362 "\n"
16363 "SYNOPSIS:\n"
16364 "\n"
16365 "plend()\n"
16366 "\n"
16367 ""},
16368 { "plend1", _wrap_plend1, METH_NOARGS, "\n"
16369 "End plotting session for current stream\n"
16370 "\n"
16371 "DESCRIPTION:\n"
16372 "\n"
16373 " Ends a plotting session for the current output stream only. See\n"
16374 " plsstrm for more info.\n"
16375 "\n"
16376 " Redacted form: plend1()\n"
16377 "\n"
16378 " This function is used in examples 1 and 20.\n"
16379 "\n"
16380 "\n"
16381 "\n"
16382 "SYNOPSIS:\n"
16383 "\n"
16384 "plend1()\n"
16385 "\n"
16386 ""},
16387 { "plenv", _wrap_plenv, METH_VARARGS, "\n"
16388 "Set up standard window and draw box\n"
16389 "\n"
16390 "DESCRIPTION:\n"
16391 "\n"
16392 " Sets up plotter environment for simple graphs by calling pladv and\n"
16393 " setting up viewport and window to sensible default values. plenv\n"
16394 " leaves a standard margin (left-hand margin of eight character heights,\n"
16395 " and a margin around the other three sides of five character heights)\n"
16396 " around most graphs for axis labels and a title. When these defaults\n"
16397 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16398 " plvasp for setting up the viewport, plwind for defining the window,\n"
16399 " and plbox for drawing the box.\n"
16400 "\n"
16401 " Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16402 "\n"
16403 " This function is used in example 1,3,9,13,14,19-22,29.\n"
16404 "\n"
16405 "\n"
16406 "\n"
16407 "SYNOPSIS:\n"
16408 "\n"
16409 "plenv(xmin, xmax, ymin, ymax, just, axis)\n"
16410 "\n"
16411 "ARGUMENTS:\n"
16412 "\n"
16413 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16414 " world coordinates).\n"
16415 "\n"
16416 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16417 " world coordinates).\n"
16418 "\n"
16419 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16420 " coordinates).\n"
16421 "\n"
16422 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16423 " coordinates).\n"
16424 "\n"
16425 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16426 " scales will not be set, the user must set up the scale before\n"
16427 " calling plenv using plsvpa, plvasp or other.\n"
16428 " 0: the x and y axes are scaled independently to use as much of\n"
16429 " the screen as possible.\n"
16430 " 1: the scales of the x and y axes are made equal.\n"
16431 " 2: the axis of the x and y axes are made equal, and the plot\n"
16432 " box will be square.\n"
16433 "\n"
16434 "\n"
16435 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16436 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16437 " -1: draw box only.\n"
16438 " 0: draw box, ticks, and numeric tick labels.\n"
16439 " 1: also draw coordinate axes at x=0 and y=0.\n"
16440 " 2: also draw a grid at major tick positions in both\n"
16441 " coordinates.\n"
16442 " 3: also draw a grid at minor tick positions in both\n"
16443 " coordinates.\n"
16444 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16445 " have to be converted to logarithms separately.)\n"
16446 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16447 " have to be converted to logarithms separately.)\n"
16448 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16449 " have to be converted to logarithms separately.)\n"
16450 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16451 " have to be converted to logarithms separately.)\n"
16452 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16453 " have to be converted to logarithms separately.)\n"
16454 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16455 " have to be converted to logarithms separately.)\n"
16456 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16457 " have to be converted to logarithms separately.)\n"
16458 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16459 " have to be converted to logarithms separately.)\n"
16460 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16461 " and y data have to be converted to logarithms separately.)\n"
16462 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16463 " and y data have to be converted to logarithms separately.)\n"
16464 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16465 " and y data have to be converted to logarithms separately.)\n"
16466 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16467 " and y data have to be converted to logarithms separately.)\n"
16468 " 40: same as 0 except date / time x labels.\n"
16469 " 41: same as 1 except date / time x labels.\n"
16470 " 42: same as 2 except date / time x labels.\n"
16471 " 43: same as 3 except date / time x labels.\n"
16472 " 50: same as 0 except date / time y labels.\n"
16473 " 51: same as 1 except date / time y labels.\n"
16474 " 52: same as 2 except date / time y labels.\n"
16475 " 53: same as 3 except date / time y labels.\n"
16476 " 60: same as 0 except date / time x and y labels.\n"
16477 " 61: same as 1 except date / time x and y labels.\n"
16478 " 62: same as 2 except date / time x and y labels.\n"
16479 " 63: same as 3 except date / time x and y labels.\n"
16480 " 70: same as 0 except custom x and y labels.\n"
16481 " 71: same as 1 except custom x and y labels.\n"
16482 " 72: same as 2 except custom x and y labels.\n"
16483 " 73: same as 3 except custom x and y labels.\n"
16484 "\n"
16485 ""},
16486 { "plenv0", _wrap_plenv0, METH_VARARGS, "\n"
16487 "Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n"
16488 "\n"
16489 "DESCRIPTION:\n"
16490 "\n"
16491 " Sets up plotter environment for simple graphs by calling pladv and\n"
16492 " setting up viewport and window to sensible default values. plenv0\n"
16493 " leaves a standard margin (left-hand margin of eight character heights,\n"
16494 " and a margin around the other three sides of five character heights)\n"
16495 " around most graphs for axis labels and a title. When these defaults\n"
16496 " are not suitable, use the individual routines plvpas, plvpor, or\n"
16497 " plvasp for setting up the viewport, plwind for defining the window,\n"
16498 " and plbox for drawing the box.\n"
16499 "\n"
16500 " Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16501 "\n"
16502 " This function is used in example 21.\n"
16503 "\n"
16504 "\n"
16505 "\n"
16506 "SYNOPSIS:\n"
16507 "\n"
16508 "plenv0(xmin, xmax, ymin, ymax, just, axis)\n"
16509 "\n"
16510 "ARGUMENTS:\n"
16511 "\n"
16512 " xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n"
16513 " world coordinates).\n"
16514 "\n"
16515 " xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n"
16516 " world coordinates).\n"
16517 "\n"
16518 " ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n"
16519 " coordinates).\n"
16520 "\n"
16521 " ymax (PLFLT, input) : Value of y at top edge of window (in world\n"
16522 " coordinates).\n"
16523 "\n"
16524 " just (PLINT, input) : Controls how the axes will be scaled: -1: the\n"
16525 " scales will not be set, the user must set up the scale before\n"
16526 " calling plenv0 using plsvpa, plvasp or other.\n"
16527 " 0: the x and y axes are scaled independently to use as much of\n"
16528 " the screen as possible.\n"
16529 " 1: the scales of the x and y axes are made equal.\n"
16530 " 2: the axis of the x and y axes are made equal, and the plot\n"
16531 " box will be square.\n"
16532 "\n"
16533 "\n"
16534 " axis (PLINT, input) : Controls drawing of the box around the plot:\n"
16535 " -2: draw no box, no tick marks, no numeric tick labels, no axes.\n"
16536 " -1: draw box only.\n"
16537 " 0: draw box, ticks, and numeric tick labels.\n"
16538 " 1: also draw coordinate axes at x=0 and y=0.\n"
16539 " 2: also draw a grid at major tick positions in both\n"
16540 " coordinates.\n"
16541 " 3: also draw a grid at minor tick positions in both\n"
16542 " coordinates.\n"
16543 " 10: same as 0 except logarithmic x tick marks. (The x data\n"
16544 " have to be converted to logarithms separately.)\n"
16545 " 11: same as 1 except logarithmic x tick marks. (The x data\n"
16546 " have to be converted to logarithms separately.)\n"
16547 " 12: same as 2 except logarithmic x tick marks. (The x data\n"
16548 " have to be converted to logarithms separately.)\n"
16549 " 13: same as 3 except logarithmic x tick marks. (The x data\n"
16550 " have to be converted to logarithms separately.)\n"
16551 " 20: same as 0 except logarithmic y tick marks. (The y data\n"
16552 " have to be converted to logarithms separately.)\n"
16553 " 21: same as 1 except logarithmic y tick marks. (The y data\n"
16554 " have to be converted to logarithms separately.)\n"
16555 " 22: same as 2 except logarithmic y tick marks. (The y data\n"
16556 " have to be converted to logarithms separately.)\n"
16557 " 23: same as 3 except logarithmic y tick marks. (The y data\n"
16558 " have to be converted to logarithms separately.)\n"
16559 " 30: same as 0 except logarithmic x and y tick marks. (The x\n"
16560 " and y data have to be converted to logarithms separately.)\n"
16561 " 31: same as 1 except logarithmic x and y tick marks. (The x\n"
16562 " and y data have to be converted to logarithms separately.)\n"
16563 " 32: same as 2 except logarithmic x and y tick marks. (The x\n"
16564 " and y data have to be converted to logarithms separately.)\n"
16565 " 33: same as 3 except logarithmic x and y tick marks. (The x\n"
16566 " and y data have to be converted to logarithms separately.)\n"
16567 " 40: same as 0 except date / time x labels.\n"
16568 " 41: same as 1 except date / time x labels.\n"
16569 " 42: same as 2 except date / time x labels.\n"
16570 " 43: same as 3 except date / time x labels.\n"
16571 " 50: same as 0 except date / time y labels.\n"
16572 " 51: same as 1 except date / time y labels.\n"
16573 " 52: same as 2 except date / time y labels.\n"
16574 " 53: same as 3 except date / time y labels.\n"
16575 " 60: same as 0 except date / time x and y labels.\n"
16576 " 61: same as 1 except date / time x and y labels.\n"
16577 " 62: same as 2 except date / time x and y labels.\n"
16578 " 63: same as 3 except date / time x and y labels.\n"
16579 " 70: same as 0 except custom x and y labels.\n"
16580 " 71: same as 1 except custom x and y labels.\n"
16581 " 72: same as 2 except custom x and y labels.\n"
16582 " 73: same as 3 except custom x and y labels.\n"
16583 "\n"
16584 ""},
16585 { "pleop", _wrap_pleop, METH_NOARGS, "\n"
16586 "Eject current page\n"
16587 "\n"
16588 "DESCRIPTION:\n"
16589 "\n"
16590 " Clears the graphics screen of an interactive device, or ejects a page\n"
16591 " on a plotter. See plbop for more information.\n"
16592 "\n"
16593 " Redacted form: pleop()\n"
16594 "\n"
16595 " This function is used in example 2,14.\n"
16596 "\n"
16597 "\n"
16598 "\n"
16599 "SYNOPSIS:\n"
16600 "\n"
16601 "pleop()\n"
16602 "\n"
16603 ""},
16604 { "plerrx", _wrap_plerrx, METH_VARARGS, "\n"
16605 "Draw error bars in x direction\n"
16606 "\n"
16607 "DESCRIPTION:\n"
16608 "\n"
16609 " Draws a set of n error bars in x direction, the i'th error bar\n"
16610 " extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n"
16611 " of the error bars are of length equal to the minor tick length\n"
16612 " (settable using plsmin).\n"
16613 "\n"
16614 " Redacted form: General: plerrx(xmin, ymax, y)\n"
16615 "\n"
16616 "\n"
16617 " This function is used in example 29.\n"
16618 "\n"
16619 "\n"
16620 "\n"
16621 "SYNOPSIS:\n"
16622 "\n"
16623 "plerrx(n, xmin, xmax, y)\n"
16624 "\n"
16625 "ARGUMENTS:\n"
16626 "\n"
16627 " n (PLINT, input) : Number of error bars to draw.\n"
16628 "\n"
16629 " xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16630 " of the left-hand endpoints of the error bars.\n"
16631 "\n"
16632 " xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n"
16633 " of the right-hand endpoints of the error bars.\n"
16634 "\n"
16635 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16636 " the error bars.\n"
16637 "\n"
16638 ""},
16639 { "plerry", _wrap_plerry, METH_VARARGS, "\n"
16640 "Draw error bars in the y direction\n"
16641 "\n"
16642 "DESCRIPTION:\n"
16643 "\n"
16644 " Draws a set of n error bars in the y direction, the i'th error bar\n"
16645 " extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n"
16646 " of the error bars are of length equal to the minor tick length\n"
16647 " (settable using plsmin).\n"
16648 "\n"
16649 " Redacted form: General: plerry(x, ymin, ymax)\n"
16650 "\n"
16651 "\n"
16652 " This function is used in example 29.\n"
16653 "\n"
16654 "\n"
16655 "\n"
16656 "SYNOPSIS:\n"
16657 "\n"
16658 "plerry(n, x, ymin, ymax)\n"
16659 "\n"
16660 "ARGUMENTS:\n"
16661 "\n"
16662 " n (PLINT, input) : Number of error bars to draw.\n"
16663 "\n"
16664 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16665 " the error bars.\n"
16666 "\n"
16667 " ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16668 " of the lower endpoints of the error bars.\n"
16669 "\n"
16670 " ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n"
16671 " of the upper endpoints of the error bars.\n"
16672 "\n"
16673 ""},
16674 { "plfamadv", _wrap_plfamadv, METH_NOARGS, "\n"
16675 "Advance to the next family file on the next new page\n"
16676 "\n"
16677 "DESCRIPTION:\n"
16678 "\n"
16679 " Advance to the next family file on the next new page.\n"
16680 "\n"
16681 " Redacted form: plfamadv()\n"
16682 "\n"
16683 " This function is not used in any examples.\n"
16684 "\n"
16685 "\n"
16686 "\n"
16687 "SYNOPSIS:\n"
16688 "\n"
16689 "plfamadv()\n"
16690 "\n"
16691 ""},
16692 { "plfill", _wrap_plfill, METH_VARARGS, "\n"
16693 "Draw filled polygon\n"
16694 "\n"
16695 "DESCRIPTION:\n"
16696 "\n"
16697 " Fills the polygon defined by the n points (\n"
16698 " x[i],\n"
16699 " y[i]) using the pattern defined by plpsty or plpat. The default fill\n"
16700 " style is a solid fill. The routine will automatically close the\n"
16701 " polygon between the last and first vertices. If multiple closed\n"
16702 " polygons are passed in x and y then plfill will fill in between them.\n"
16703 "\n"
16704 " Redacted form: plfill(x,y)\n"
16705 "\n"
16706 " This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n"
16707 "\n"
16708 "\n"
16709 "\n"
16710 "SYNOPSIS:\n"
16711 "\n"
16712 "plfill(n, x, y)\n"
16713 "\n"
16714 "ARGUMENTS:\n"
16715 "\n"
16716 " n (PLINT, input) : Number of vertices in polygon.\n"
16717 "\n"
16718 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16719 " vertices.\n"
16720 "\n"
16721 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16722 " vertices.\n"
16723 "\n"
16724 ""},
16725 { "plfill3", _wrap_plfill3, METH_VARARGS, "\n"
16726 "Draw filled polygon in 3D\n"
16727 "\n"
16728 "DESCRIPTION:\n"
16729 "\n"
16730 " Fills the 3D polygon defined by the n points in the x, y, and z\n"
16731 " vectors using the pattern defined by plpsty or plpat. The routine\n"
16732 " will automatically close the polygon between the last and first\n"
16733 " vertices. If multiple closed polygons are passed in x, y, and z then\n"
16734 " plfill3 will fill in between them.\n"
16735 "\n"
16736 " Redacted form: General: plfill3(x, y, z)\n"
16737 "\n"
16738 "\n"
16739 " This function is used in example 15.\n"
16740 "\n"
16741 "\n"
16742 "\n"
16743 "SYNOPSIS:\n"
16744 "\n"
16745 "plfill3(n, x, y, z)\n"
16746 "\n"
16747 "ARGUMENTS:\n"
16748 "\n"
16749 " n (PLINT, input) : Number of vertices in polygon.\n"
16750 "\n"
16751 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16752 " vertices.\n"
16753 "\n"
16754 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16755 " vertices.\n"
16756 "\n"
16757 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
16758 " vertices.\n"
16759 "\n"
16760 ""},
16761 { "plgradient", _wrap_plgradient, METH_VARARGS, "\n"
16762 "Draw linear gradient inside polygon\n"
16763 "\n"
16764 "DESCRIPTION:\n"
16765 "\n"
16766 " Draw a linear gradient using cmap1 inside the polygon defined by the n\n"
16767 " points (\n"
16768 " x[i],\n"
16769 " y[i]). Interpretation of the polygon is the same as for plfill. The\n"
16770 " polygon coordinates and the gradient angle are all expressed in world\n"
16771 " coordinates. The angle from the x axis for both the rotated\n"
16772 " coordinate system and the gradient vector is specified by angle. The\n"
16773 " magnitude of the gradient vector is the difference between the maximum\n"
16774 " and minimum values of x for the vertices in the rotated coordinate\n"
16775 " system. The origin of the gradient vector can be interpreted as being\n"
16776 " anywhere on the line corresponding to the minimum x value for the\n"
16777 " vertices in the rotated coordinate system. The distance along the\n"
16778 " gradient vector is linearly transformed to the independent variable of\n"
16779 " color map 1 which ranges from 0. at the tail of the gradient vector to\n"
16780 " 1. at the head of the gradient vector. What is drawn is the RGBA\n"
16781 " color corresponding to the independent variable of cmap1. For more\n"
16782 " information about cmap1 (see the PLplot documentation).\n"
16783 "\n"
16784 " Redacted form: plgradient(x,y,angle)\n"
16785 "\n"
16786 " This function is used in examples 25 and 30.\n"
16787 "\n"
16788 "\n"
16789 "\n"
16790 "SYNOPSIS:\n"
16791 "\n"
16792 "plgradient(n, x, y, angle)\n"
16793 "\n"
16794 "ARGUMENTS:\n"
16795 "\n"
16796 " n (PLINT, input) : Number of vertices in polygon.\n"
16797 "\n"
16798 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
16799 " vertices.\n"
16800 "\n"
16801 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
16802 " vertices.\n"
16803 "\n"
16804 " angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n"
16805 " axis.\n"
16806 "\n"
16807 ""},
16808 { "plflush", _wrap_plflush, METH_NOARGS, "\n"
16809 "Flushes the output stream\n"
16810 "\n"
16811 "DESCRIPTION:\n"
16812 "\n"
16813 " Flushes the output stream. Use sparingly, if at all.\n"
16814 "\n"
16815 " Redacted form: plflush()\n"
16816 "\n"
16817 " This function is used in examples 1 and 14.\n"
16818 "\n"
16819 "\n"
16820 "\n"
16821 "SYNOPSIS:\n"
16822 "\n"
16823 "plflush()\n"
16824 "\n"
16825 ""},
16826 { "plfont", _wrap_plfont, METH_O, "\n"
16827 "Set font\n"
16828 "\n"
16829 "DESCRIPTION:\n"
16830 "\n"
16831 " Sets the font used for subsequent text and symbols. For devices that\n"
16832 " still use Hershey fonts this routine has no effect unless the Hershey\n"
16833 " fonts with extended character set are loaded (see plfontld). For\n"
16834 " unicode-aware devices that use system fonts instead of Hershey fonts,\n"
16835 " this routine calls the plsfci routine with argument set up\n"
16836 " appropriately for the various cases below. However, this method of\n"
16837 " specifying the font for unicode-aware devices is deprecated, and the\n"
16838 " much more flexible method of calling plsfont directly is recommended\n"
16839 " instead (where plsfont provides a user-friendly interface to plsfci),\n"
16840 "\n"
16841 " Redacted form: plfont(ifont)\n"
16842 "\n"
16843 " This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n"
16844 "\n"
16845 "\n"
16846 "\n"
16847 "SYNOPSIS:\n"
16848 "\n"
16849 "plfont(ifont)\n"
16850 "\n"
16851 "ARGUMENTS:\n"
16852 "\n"
16853 " ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n"
16854 " (simplest and fastest)\n"
16855 " 2: Serif font\n"
16856 " 3: Italic font\n"
16857 " 4: Script font\n"
16858 "\n"
16859 ""},
16860 { "plfontld", _wrap_plfontld, METH_O, "\n"
16861 "Load Hershey fonts\n"
16862 "\n"
16863 "DESCRIPTION:\n"
16864 "\n"
16865 " Loads the Hershey fonts used for text and symbols. This routine may\n"
16866 " be called before or after initializing PLplot. If not explicitly\n"
16867 " called before PLplot initialization, then by default that\n"
16868 " initialization loads Hershey fonts with the extended character set.\n"
16869 " This routine only has a practical effect for devices that still use\n"
16870 " Hershey fonts (as opposed to modern devices that use unicode-aware\n"
16871 " system fonts instead of Hershey fonts).\n"
16872 "\n"
16873 " Redacted form: plfontld(fnt)\n"
16874 "\n"
16875 " This function is used in examples 1 and 7.\n"
16876 "\n"
16877 "\n"
16878 "\n"
16879 "SYNOPSIS:\n"
16880 "\n"
16881 "plfontld(fnt)\n"
16882 "\n"
16883 "ARGUMENTS:\n"
16884 "\n"
16885 " fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n"
16886 " A zero value specifies Hershey fonts with the standard character\n"
16887 " set and a non-zero value (the default assumed if plfontld is never\n"
16888 " called) specifies Hershey fonts with the extended character set.\n"
16889 "\n"
16890 ""},
16891 { "plgchr", _wrap_plgchr, METH_NOARGS, "\n"
16892 "Get character default height and current (scaled) height\n"
16893 "\n"
16894 "DESCRIPTION:\n"
16895 "\n"
16896 " Get character default height and current (scaled) height.\n"
16897 "\n"
16898 " Redacted form: plgchr(p_def, p_ht)\n"
16899 "\n"
16900 " This function is used in example 23.\n"
16901 "\n"
16902 "\n"
16903 "\n"
16904 "SYNOPSIS:\n"
16905 "\n"
16906 "plgchr(p_def, p_ht)\n"
16907 "\n"
16908 "ARGUMENTS:\n"
16909 "\n"
16910 " p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n"
16911 " character height (mm).\n"
16912 "\n"
16913 " p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n"
16914 " character height (mm).\n"
16915 "\n"
16916 ""},
16917 { "plgcol0", _wrap_plgcol0, METH_O, "\n"
16918 "Returns 8-bit RGB values for given color index from cmap0\n"
16919 "\n"
16920 "DESCRIPTION:\n"
16921 "\n"
16922 " Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n"
16923 " PLplot documentation). Values are negative if an invalid color id is\n"
16924 " given.\n"
16925 "\n"
16926 " Redacted form: plgcol0(icol0, r, g, b)\n"
16927 "\n"
16928 " This function is used in example 2.\n"
16929 "\n"
16930 "\n"
16931 "\n"
16932 "SYNOPSIS:\n"
16933 "\n"
16934 "plgcol0(icol0, r, g, b)\n"
16935 "\n"
16936 "ARGUMENTS:\n"
16937 "\n"
16938 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16939 "\n"
16940 " r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n"
16941 " value.\n"
16942 "\n"
16943 " g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n"
16944 " value.\n"
16945 "\n"
16946 " b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n"
16947 " value.\n"
16948 "\n"
16949 ""},
16950 { "plgcol0a", _wrap_plgcol0a, METH_O, "\n"
16951 "Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n"
16952 "\n"
16953 "DESCRIPTION:\n"
16954 "\n"
16955 " Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n"
16956 " (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n"
16957 " Values are negative if an invalid color id is given.\n"
16958 "\n"
16959 " Redacted form: plgcola(r, g, b)\n"
16960 "\n"
16961 " This function is used in example 30.\n"
16962 "\n"
16963 "\n"
16964 "\n"
16965 "SYNOPSIS:\n"
16966 "\n"
16967 "plgcol0a(icol0, r, g, b, alpha)\n"
16968 "\n"
16969 "ARGUMENTS:\n"
16970 "\n"
16971 " icol0 (PLINT, input) : Index of desired cmap0 color.\n"
16972 "\n"
16973 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
16974 " in the range from 0 to 255.\n"
16975 "\n"
16976 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
16977 " in the range from 0 to 255.\n"
16978 "\n"
16979 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
16980 " in the range from 0 to 255.\n"
16981 "\n"
16982 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
16983 " transparency in the range from (0.0-1.0).\n"
16984 "\n"
16985 ""},
16986 { "plgcolbg", _wrap_plgcolbg, METH_NOARGS, "\n"
16987 "Returns the background color (cmap0[0]) by 8-bit RGB value\n"
16988 "\n"
16989 "DESCRIPTION:\n"
16990 "\n"
16991 " Returns the background color (cmap0[0]) by 8-bit RGB value.\n"
16992 "\n"
16993 " Redacted form: plgcolbg(r, g, b)\n"
16994 "\n"
16995 " This function is used in example 31.\n"
16996 "\n"
16997 "\n"
16998 "\n"
16999 "SYNOPSIS:\n"
17000 "\n"
17001 "plgcolbg(r, g, b)\n"
17002 "\n"
17003 "ARGUMENTS:\n"
17004 "\n"
17005 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
17006 " in the range from 0 to 255.\n"
17007 "\n"
17008 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
17009 " in the range from 0 to 255.\n"
17010 "\n"
17011 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17012 " in the range from 0 to 255.\n"
17013 "\n"
17014 ""},
17015 { "plgcolbga", _wrap_plgcolbga, METH_NOARGS, "\n"
17016 "Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n"
17017 "\n"
17018 "DESCRIPTION:\n"
17019 "\n"
17020 " Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n"
17021 " alpha transparency value.\n"
17022 "\n"
17023 " This function is used in example 31.\n"
17024 "\n"
17025 "\n"
17026 "\n"
17027 "SYNOPSIS:\n"
17028 "\n"
17029 "plgcolbga(r, g, b, alpha)\n"
17030 "\n"
17031 "ARGUMENTS:\n"
17032 "\n"
17033 " r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n"
17034 " in the range from 0 to 255.\n"
17035 "\n"
17036 " g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n"
17037 " in the range from 0 to 255.\n"
17038 "\n"
17039 " b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n"
17040 " in the range from 0 to 255.\n"
17041 "\n"
17042 " alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n"
17043 " transparency in the range (0.0-1.0).\n"
17044 "\n"
17045 ""},
17046 { "plgcompression", _wrap_plgcompression, METH_NOARGS, "\n"
17047 "Get the current device-compression setting\n"
17048 "\n"
17049 "DESCRIPTION:\n"
17050 "\n"
17051 " Get the current device-compression setting. This parameter is only\n"
17052 " used for drivers that provide compression.\n"
17053 "\n"
17054 " Redacted form: plgcompression(compression)\n"
17055 "\n"
17056 " This function is used in example 31.\n"
17057 "\n"
17058 "\n"
17059 "\n"
17060 "SYNOPSIS:\n"
17061 "\n"
17062 "plgcompression(compression)\n"
17063 "\n"
17064 "ARGUMENTS:\n"
17065 "\n"
17066 " compression (PLINT_NC_SCALAR, output) : Returned value of the\n"
17067 " compression setting for the current device.\n"
17068 "\n"
17069 ""},
17070 { "plgdev", _wrap_plgdev, METH_NOARGS, "\n"
17071 "Get the current device (keyword) name\n"
17072 "\n"
17073 "DESCRIPTION:\n"
17074 "\n"
17075 " Get the current device (keyword) name. Note: you must have allocated\n"
17076 " space for this (80 characters is safe).\n"
17077 "\n"
17078 " Redacted form: plgdev(p_dev)\n"
17079 "\n"
17080 " This function is used in example 14.\n"
17081 "\n"
17082 "\n"
17083 "\n"
17084 "SYNOPSIS:\n"
17085 "\n"
17086 "plgdev(p_dev)\n"
17087 "\n"
17088 "ARGUMENTS:\n"
17089 "\n"
17090 " p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17091 " (with preallocated length of 80 characters or more) containing the\n"
17092 " device (keyword) name.\n"
17093 "\n"
17094 ""},
17095 { "plgdidev", _wrap_plgdidev, METH_NOARGS, "\n"
17096 "Get parameters that define current device-space window\n"
17097 "\n"
17098 "DESCRIPTION:\n"
17099 "\n"
17100 " Get relative margin width, aspect ratio, and relative justification\n"
17101 " that define current device-space window. If plsdidev has not been\n"
17102 " called the default values pointed to by p_mar, p_aspect, p_jx, and\n"
17103 " p_jy will all be 0.\n"
17104 "\n"
17105 " Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17106 "\n"
17107 " This function is used in example 31.\n"
17108 "\n"
17109 "\n"
17110 "\n"
17111 "SYNOPSIS:\n"
17112 "\n"
17113 "plgdidev(p_mar, p_aspect, p_jx, p_jy)\n"
17114 "\n"
17115 "ARGUMENTS:\n"
17116 "\n"
17117 " p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17118 " margin width.\n"
17119 "\n"
17120 " p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n"
17121 " ratio.\n"
17122 "\n"
17123 " p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17124 " justification in x.\n"
17125 "\n"
17126 " p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17127 " justification in y.\n"
17128 "\n"
17129 ""},
17130 { "plgdiori", _wrap_plgdiori, METH_NOARGS, "\n"
17131 "Get plot orientation\n"
17132 "\n"
17133 "DESCRIPTION:\n"
17134 "\n"
17135 " Get plot orientation parameter which is multiplied by 90 degrees to\n"
17136 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
17137 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
17138 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
17139 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
17140 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n"
17141 " not been called the default value pointed to by p_rot will be 0.\n"
17142 "\n"
17143 " Redacted form: plgdiori(p_rot)\n"
17144 "\n"
17145 " This function is not used in any examples.\n"
17146 "\n"
17147 "\n"
17148 "\n"
17149 "SYNOPSIS:\n"
17150 "\n"
17151 "plgdiori(p_rot)\n"
17152 "\n"
17153 "ARGUMENTS:\n"
17154 "\n"
17155 " p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n"
17156 " parameter.\n"
17157 "\n"
17158 ""},
17159 { "plgdiplt", _wrap_plgdiplt, METH_NOARGS, "\n"
17160 "Get parameters that define current plot-space window\n"
17161 "\n"
17162 "DESCRIPTION:\n"
17163 "\n"
17164 " Get relative minima and maxima that define current plot-space window.\n"
17165 " If plsdiplt has not been called the default values pointed to by\n"
17166 " p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n"
17167 "\n"
17168 " Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17169 "\n"
17170 " This function is used in example 31.\n"
17171 "\n"
17172 "\n"
17173 "\n"
17174 "SYNOPSIS:\n"
17175 "\n"
17176 "plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n"
17177 "\n"
17178 "ARGUMENTS:\n"
17179 "\n"
17180 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17181 " minimum in x.\n"
17182 "\n"
17183 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17184 " minimum in y.\n"
17185 "\n"
17186 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17187 " maximum in x.\n"
17188 "\n"
17189 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n"
17190 " maximum in y.\n"
17191 "\n"
17192 ""},
17193 { "plgfam", _wrap_plgfam, METH_NOARGS, "\n"
17194 "Get family file parameters\n"
17195 "\n"
17196 "DESCRIPTION:\n"
17197 "\n"
17198 " Gets information about current family file, if familying is enabled.\n"
17199 " See the PLplot documentation for more information.\n"
17200 "\n"
17201 " Redacted form: plgfam(p_fam, p_num, p_bmax)\n"
17202 "\n"
17203 " This function is used in examples 14 and 31.\n"
17204 "\n"
17205 "\n"
17206 "\n"
17207 "SYNOPSIS:\n"
17208 "\n"
17209 "plgfam(p_fam, p_num, p_bmax)\n"
17210 "\n"
17211 "ARGUMENTS:\n"
17212 "\n"
17213 " p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17214 " family flag value. If nonzero, familying is enabled for the\n"
17215 " current device.\n"
17216 "\n"
17217 " p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17218 " family file number.\n"
17219 "\n"
17220 " p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17221 " file size (in bytes) for a family file.\n"
17222 "\n"
17223 ""},
17224 { "plgfci", _wrap_plgfci, METH_NOARGS, "\n"
17225 "Get FCI (font characterization integer)\n"
17226 "\n"
17227 "DESCRIPTION:\n"
17228 "\n"
17229 " Gets information about the current font using the FCI approach. See\n"
17230 " the PLplot documentation for more information.\n"
17231 "\n"
17232 " Redacted form: plgfci(p_fci)\n"
17233 "\n"
17234 " This function is used in example 23.\n"
17235 "\n"
17236 "\n"
17237 "\n"
17238 "SYNOPSIS:\n"
17239 "\n"
17240 "plgfci(p_fci)\n"
17241 "\n"
17242 "ARGUMENTS:\n"
17243 "\n"
17244 " p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n"
17245 " FCI value.\n"
17246 "\n"
17247 ""},
17248 { "plgfnam", _wrap_plgfnam, METH_NOARGS, "\n"
17249 "Get output file name\n"
17250 "\n"
17251 "DESCRIPTION:\n"
17252 "\n"
17253 " Gets the current output file name, if applicable.\n"
17254 "\n"
17255 " Redacted form: plgfnam(fnam)\n"
17256 "\n"
17257 " This function is used in example 31.\n"
17258 "\n"
17259 "\n"
17260 "\n"
17261 "SYNOPSIS:\n"
17262 "\n"
17263 "plgfnam(fnam)\n"
17264 "\n"
17265 "ARGUMENTS:\n"
17266 "\n"
17267 " fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17268 " (with preallocated length of 80 characters or more) containing the\n"
17269 " file name.\n"
17270 "\n"
17271 ""},
17272 { "plgfont", _wrap_plgfont, METH_NOARGS, "\n"
17273 "Get family, style and weight of the current font\n"
17274 "\n"
17275 "DESCRIPTION:\n"
17276 "\n"
17277 " Gets information about current font. See the PLplot documentation for\n"
17278 " more information on font selection.\n"
17279 "\n"
17280 " Redacted form: plgfont(p_family, p_style, p_weight)\n"
17281 "\n"
17282 " This function is used in example 23.\n"
17283 "\n"
17284 "\n"
17285 "\n"
17286 "SYNOPSIS:\n"
17287 "\n"
17288 "plgfont(p_family, p_style, p_weight)\n"
17289 "\n"
17290 "ARGUMENTS:\n"
17291 "\n"
17292 " p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17293 " font family. The available values are given by the PL_FCI_*\n"
17294 " constants in plplot.h. Current options are PL_FCI_SANS,\n"
17295 " PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n"
17296 " p_family is NULL then the font family is not returned.\n"
17297 "\n"
17298 " p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17299 " font style. The available values are given by the PL_FCI_*\n"
17300 " constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n"
17301 " PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n"
17302 " style is not returned.\n"
17303 "\n"
17304 " p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17305 " font weight. The available values are given by the PL_FCI_*\n"
17306 " constants in plplot.h. Current options are PL_FCI_MEDIUM and\n"
17307 " PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n"
17308 " returned.\n"
17309 "\n"
17310 ""},
17311 { "plglevel", _wrap_plglevel, METH_NOARGS, "\n"
17312 "Get the (current) run level\n"
17313 "\n"
17314 "DESCRIPTION:\n"
17315 "\n"
17316 " Get the (current) run level. Valid settings are: 0, uninitialized\n"
17317 " 1, initialized\n"
17318 " 2, viewport defined\n"
17319 " 3, world coordinates defined\n"
17320 "\n"
17321 "\n"
17322 " Redacted form: plglevel(p_level)\n"
17323 "\n"
17324 " This function is used in example 31.\n"
17325 "\n"
17326 "\n"
17327 "\n"
17328 "SYNOPSIS:\n"
17329 "\n"
17330 "plglevel(p_level)\n"
17331 "\n"
17332 "ARGUMENTS:\n"
17333 "\n"
17334 " p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n"
17335 " level.\n"
17336 "\n"
17337 ""},
17338 { "plgpage", _wrap_plgpage, METH_NOARGS, "\n"
17339 "Get page parameters\n"
17340 "\n"
17341 "DESCRIPTION:\n"
17342 "\n"
17343 " Gets the current page configuration. The length and offset values are\n"
17344 " expressed in units that are specific to the current driver. For\n"
17345 " instance: screen drivers will usually interpret them as number of\n"
17346 " pixels, whereas printer drivers will usually use mm.\n"
17347 "\n"
17348 " Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17349 "\n"
17350 " This function is used in examples 14 and 31.\n"
17351 "\n"
17352 "\n"
17353 "\n"
17354 "SYNOPSIS:\n"
17355 "\n"
17356 "plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n"
17357 "\n"
17358 "ARGUMENTS:\n"
17359 "\n"
17360 " p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17361 " pixels/inch (DPI) in x.\n"
17362 "\n"
17363 " p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n"
17364 " pixels/inch (DPI) in y.\n"
17365 "\n"
17366 " p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17367 " length.\n"
17368 "\n"
17369 " p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17370 " length.\n"
17371 "\n"
17372 " p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n"
17373 " offset.\n"
17374 "\n"
17375 " p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n"
17376 " offset.\n"
17377 "\n"
17378 ""},
17379 { "plgra", _wrap_plgra, METH_NOARGS, "\n"
17380 "Switch to graphics screen\n"
17381 "\n"
17382 "DESCRIPTION:\n"
17383 "\n"
17384 " Sets an interactive device to graphics mode, used in conjunction with\n"
17385 " pltext to allow graphics and text to be interspersed. On a device\n"
17386 " which supports separate text and graphics windows, this command causes\n"
17387 " control to be switched to the graphics window. If already in graphics\n"
17388 " mode, this command is ignored. It is also ignored on devices which\n"
17389 " only support a single window or use a different method for shifting\n"
17390 " focus. See also pltext.\n"
17391 "\n"
17392 " Redacted form: plgra()\n"
17393 "\n"
17394 " This function is used in example 1.\n"
17395 "\n"
17396 "\n"
17397 "\n"
17398 "SYNOPSIS:\n"
17399 "\n"
17400 "plgra()\n"
17401 "\n"
17402 ""},
17403 { "plgriddata", _wrap_plgriddata, METH_VARARGS, "\n"
17404 "Grid data from irregularly sampled data\n"
17405 "\n"
17406 "DESCRIPTION:\n"
17407 "\n"
17408 " Real world data is frequently irregularly sampled, but PLplot 3D plots\n"
17409 " require data organized as a grid, i.e., with x sample point values\n"
17410 " independent of y coordinate and vice versa. This function takes\n"
17411 " irregularly sampled data from the x[npts], y[npts], and z[npts]\n"
17412 " vectors; reads the desired grid location from the input vectors\n"
17413 " xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n"
17414 " grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n"
17415 " interpolate the data to the grid is specified with the argument type\n"
17416 " which can have one parameter specified in argument data.\n"
17417 "\n"
17418 " Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n"
17419 " Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n"
17420 "\n"
17421 "\n"
17422 " This function is used in example 21.\n"
17423 "\n"
17424 "\n"
17425 "\n"
17426 "SYNOPSIS:\n"
17427 "\n"
17428 "plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n"
17429 "\n"
17430 "ARGUMENTS:\n"
17431 "\n"
17432 " x (PLFLT_VECTOR, input) : The input x vector.\n"
17433 "\n"
17434 " y (PLFLT_VECTOR, input) : The input y vector.\n"
17435 "\n"
17436 " z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n"
17437 " y[i], z[i] represents one data sample coordinate.\n"
17438 "\n"
17439 " npts (PLINT, input) : The number of data samples in the x, y and z\n"
17440 " vectors.\n"
17441 "\n"
17442 " xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17443 " in the x direction. Usually xg has nptsx equally spaced values\n"
17444 " from the minimum to the maximum values of the x input vector.\n"
17445 "\n"
17446 " nptsx (PLINT, input) : The number of points in the xg vector.\n"
17447 "\n"
17448 " yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n"
17449 " in the y direction. Similar to the xg parameter.\n"
17450 "\n"
17451 " nptsy (PLINT, input) : The number of points in the yg vector.\n"
17452 "\n"
17453 " zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n"
17454 " where data lies in the grid specified by xg and yg. Therefore the\n"
17455 " zg matrix must be dimensioned\n"
17456 " nptsx by\n"
17457 " nptsy.\n"
17458 "\n"
17459 " type (PLINT, input) : The type of grid interpolation algorithm to\n"
17460 " use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n"
17461 " GRID_DTLI: Delaunay Triangulation Linear Interpolation\n"
17462 " GRID_NNI: Natural Neighbors Interpolation\n"
17463 " GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n"
17464 " GRID_NNLI: Nearest Neighbors Linear Interpolation\n"
17465 " GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n"
17466 " Weighted\n"
17467 " For details of the algorithms read the source file plgridd.c.\n"
17468 "\n"
17469 " data (PLFLT, input) : Some gridding algorithms require extra data,\n"
17470 " which can be specified through this argument. Currently, for\n"
17471 " algorithm: GRID_NNIDW, data specifies the number of neighbors to\n"
17472 " use, the lower the value, the noisier (more local) the\n"
17473 " approximation is.\n"
17474 " GRID_NNLI, data specifies what a thin triangle is, in the\n"
17475 " range [1. .. 2.]. High values enable the usage of very thin\n"
17476 " triangles for interpolation, possibly resulting in error in\n"
17477 " the approximation.\n"
17478 " GRID_NNI, only weights greater than data will be accepted. If\n"
17479 " 0, all weights will be accepted.\n"
17480 "\n"
17481 ""},
17482 { "plgspa", _wrap_plgspa, METH_NOARGS, "\n"
17483 "Get current subpage parameters\n"
17484 "\n"
17485 "DESCRIPTION:\n"
17486 "\n"
17487 " Gets the size of the current subpage in millimeters measured from the\n"
17488 " bottom left hand corner of the output device page or screen. Can be\n"
17489 " used in conjunction with plsvpa for setting the size of a viewport in\n"
17490 " absolute coordinates (millimeters).\n"
17491 "\n"
17492 " Redacted form: plgspa(xmin, xmax, ymin, ymax)\n"
17493 "\n"
17494 " This function is used in example 23.\n"
17495 "\n"
17496 "\n"
17497 "\n"
17498 "SYNOPSIS:\n"
17499 "\n"
17500 "plgspa(xmin, xmax, ymin, ymax)\n"
17501 "\n"
17502 "ARGUMENTS:\n"
17503 "\n"
17504 " xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17505 " the left hand edge of the subpage in millimeters.\n"
17506 "\n"
17507 " xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17508 " the right hand edge of the subpage in millimeters.\n"
17509 "\n"
17510 " ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17511 " the bottom edge of the subpage in millimeters.\n"
17512 "\n"
17513 " ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n"
17514 " the top edge of the subpage in millimeters.\n"
17515 "\n"
17516 ""},
17517 { "plgstrm", _wrap_plgstrm, METH_NOARGS, "\n"
17518 "Get current stream number\n"
17519 "\n"
17520 "DESCRIPTION:\n"
17521 "\n"
17522 " Gets the number of the current output stream. See also plsstrm.\n"
17523 "\n"
17524 " Redacted form: plgstrm(p_strm)\n"
17525 "\n"
17526 " This function is used in example 1,20.\n"
17527 "\n"
17528 "\n"
17529 "\n"
17530 "SYNOPSIS:\n"
17531 "\n"
17532 "plgstrm(p_strm)\n"
17533 "\n"
17534 "ARGUMENTS:\n"
17535 "\n"
17536 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n"
17537 " stream value.\n"
17538 "\n"
17539 ""},
17540 { "plgver", _wrap_plgver, METH_NOARGS, "\n"
17541 "Get the current library version number\n"
17542 "\n"
17543 "DESCRIPTION:\n"
17544 "\n"
17545 " Get the current library version number. Note: you must have allocated\n"
17546 " space for this (80 characters is safe).\n"
17547 "\n"
17548 " Redacted form: plgver(p_ver)\n"
17549 "\n"
17550 " This function is used in example 1.\n"
17551 "\n"
17552 "\n"
17553 "\n"
17554 "SYNOPSIS:\n"
17555 "\n"
17556 "plgver(p_ver)\n"
17557 "\n"
17558 "ARGUMENTS:\n"
17559 "\n"
17560 " p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n"
17561 " (with preallocated length of 80 characters or more) containing the\n"
17562 " PLplot version number.\n"
17563 "\n"
17564 ""},
17565 { "plgvpd", _wrap_plgvpd, METH_NOARGS, "\n"
17566 "Get viewport limits in normalized device coordinates\n"
17567 "\n"
17568 "DESCRIPTION:\n"
17569 "\n"
17570 " Get viewport limits in normalized device coordinates.\n"
17571 "\n"
17572 " Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17573 "\n"
17574 "\n"
17575 " This function is used in example 31.\n"
17576 "\n"
17577 "\n"
17578 "\n"
17579 "SYNOPSIS:\n"
17580 "\n"
17581 "plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17582 "\n"
17583 "ARGUMENTS:\n"
17584 "\n"
17585 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17586 " viewport limit of the normalized device coordinate in x.\n"
17587 "\n"
17588 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17589 " viewport limit of the normalized device coordinate in x.\n"
17590 "\n"
17591 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17592 " viewport limit of the normalized device coordinate in y.\n"
17593 "\n"
17594 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17595 " viewport limit of the normalized device coordinate in y.\n"
17596 "\n"
17597 ""},
17598 { "plgvpw", _wrap_plgvpw, METH_NOARGS, "\n"
17599 "Get viewport limits in world coordinates\n"
17600 "\n"
17601 "DESCRIPTION:\n"
17602 "\n"
17603 " Get viewport limits in world coordinates.\n"
17604 "\n"
17605 " Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17606 "\n"
17607 "\n"
17608 " This function is used in example 31.\n"
17609 "\n"
17610 "\n"
17611 "\n"
17612 "SYNOPSIS:\n"
17613 "\n"
17614 "plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n"
17615 "\n"
17616 "ARGUMENTS:\n"
17617 "\n"
17618 " p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17619 " viewport limit of the world coordinate in x.\n"
17620 "\n"
17621 " p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17622 " viewport limit of the world coordinate in x.\n"
17623 "\n"
17624 " p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n"
17625 " viewport limit of the world coordinate in y.\n"
17626 "\n"
17627 " p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n"
17628 " viewport limit of the world coordinate in y.\n"
17629 "\n"
17630 ""},
17631 { "plgxax", _wrap_plgxax, METH_NOARGS, "\n"
17632 "Get x axis parameters\n"
17633 "\n"
17634 "DESCRIPTION:\n"
17635 "\n"
17636 " Returns current values of the p_digmax and p_digits flags for the x\n"
17637 " axis. p_digits is updated after the plot is drawn, so this routine\n"
17638 " should only be called after the call to plbox (or plbox3) is complete.\n"
17639 " See the PLplot documentation for more information.\n"
17640 "\n"
17641 " Redacted form: plgxax(p_digmax, p_digits)\n"
17642 "\n"
17643 " This function is used in example 31.\n"
17644 "\n"
17645 "\n"
17646 "\n"
17647 "SYNOPSIS:\n"
17648 "\n"
17649 "plgxax(p_digmax, p_digits)\n"
17650 "\n"
17651 "ARGUMENTS:\n"
17652 "\n"
17653 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17654 " number of digits for the x axis. If nonzero, the printed label\n"
17655 " has been switched to a floating-point representation when the\n"
17656 " number of digits exceeds this value.\n"
17657 "\n"
17658 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17659 " number of digits for the numeric labels (x axis) from the last\n"
17660 " plot.\n"
17661 "\n"
17662 ""},
17663 { "plgyax", _wrap_plgyax, METH_NOARGS, "\n"
17664 "Get y axis parameters\n"
17665 "\n"
17666 "DESCRIPTION:\n"
17667 "\n"
17668 " Identical to plgxax, except that arguments are flags for y axis. See\n"
17669 " the description of plgxax for more detail.\n"
17670 "\n"
17671 " Redacted form: plgyax(p_digmax, p_digits)\n"
17672 "\n"
17673 " This function is used in example 31.\n"
17674 "\n"
17675 "\n"
17676 "\n"
17677 "SYNOPSIS:\n"
17678 "\n"
17679 "plgyax(p_digmax, p_digits)\n"
17680 "\n"
17681 "ARGUMENTS:\n"
17682 "\n"
17683 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17684 " number of digits for the y axis. If nonzero, the printed label\n"
17685 " has been switched to a floating-point representation when the\n"
17686 " number of digits exceeds this value.\n"
17687 "\n"
17688 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17689 " number of digits for the numeric labels (y axis) from the last\n"
17690 " plot.\n"
17691 "\n"
17692 ""},
17693 { "plgzax", _wrap_plgzax, METH_NOARGS, "\n"
17694 "Get z axis parameters\n"
17695 "\n"
17696 "DESCRIPTION:\n"
17697 "\n"
17698 " Identical to plgxax, except that arguments are flags for z axis. See\n"
17699 " the description of plgxax for more detail.\n"
17700 "\n"
17701 " Redacted form: plgzax(p_digmax, p_digits)\n"
17702 "\n"
17703 " This function is used in example 31.\n"
17704 "\n"
17705 "\n"
17706 "\n"
17707 "SYNOPSIS:\n"
17708 "\n"
17709 "plgzax(p_digmax, p_digits)\n"
17710 "\n"
17711 "ARGUMENTS:\n"
17712 "\n"
17713 " p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n"
17714 " number of digits for the z axis. If nonzero, the printed label\n"
17715 " has been switched to a floating-point representation when the\n"
17716 " number of digits exceeds this value.\n"
17717 "\n"
17718 " p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n"
17719 " number of digits for the numeric labels (z axis) from the last\n"
17720 " plot.\n"
17721 "\n"
17722 ""},
17723 { "plhist", _wrap_plhist, METH_VARARGS, "\n"
17724 "Plot a histogram from unbinned data\n"
17725 "\n"
17726 "DESCRIPTION:\n"
17727 "\n"
17728 " Plots a histogram from n data points stored in the data vector. This\n"
17729 " routine bins the data into nbin bins equally spaced between datmin and\n"
17730 " datmax, and calls plbin to draw the resulting histogram. Parameter\n"
17731 " opt allows, among other things, the histogram either to be plotted in\n"
17732 " an existing window or causes plhist to call plenv with suitable limits\n"
17733 " before plotting the histogram.\n"
17734 "\n"
17735 " Redacted form: plhist(data, datmin, datmax, nbin, opt)\n"
17736 "\n"
17737 " This function is used in example 5.\n"
17738 "\n"
17739 "\n"
17740 "\n"
17741 "SYNOPSIS:\n"
17742 "\n"
17743 "plhist(n, data, datmin, datmax, nbin, opt)\n"
17744 "\n"
17745 "ARGUMENTS:\n"
17746 "\n"
17747 " n (PLINT, input) : Number of data points.\n"
17748 "\n"
17749 " data (PLFLT_VECTOR, input) : A vector containing the values of the\n"
17750 " n data points.\n"
17751 "\n"
17752 " datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n"
17753 "\n"
17754 " datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n"
17755 "\n"
17756 " nbin (PLINT, input) : Number of (equal-sized) bins into which to\n"
17757 " divide the interval xmin to xmax.\n"
17758 "\n"
17759 " opt (PLINT, input) : Is a combination of several flags:\n"
17760 " opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n"
17761 " the histogram data, the outer bins are expanded to fill up the\n"
17762 " entire x-axis, data outside the given extremes are assigned to the\n"
17763 " outer bins and bins of zero height are simply drawn.\n"
17764 " opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n"
17765 " to fit the histogram data, without this flag, plenv is called\n"
17766 " to set the world coordinates.\n"
17767 " opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n"
17768 " extremes are not taken into account. This option should\n"
17769 " probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n"
17770 " properly present the data.\n"
17771 " opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n"
17772 " size as the ones inside.\n"
17773 " opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n"
17774 " (there is a gap for such bins).\n"
17775 "\n"
17776 ""},
17777 { "plhlsrgb", _wrap_plhlsrgb, METH_VARARGS, "\n"
17778 "Convert HLS color to RGB\n"
17779 "\n"
17780 "DESCRIPTION:\n"
17781 "\n"
17782 " Convert HLS color coordinates to RGB.\n"
17783 "\n"
17784 " Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17785 "\n"
17786 "\n"
17787 " This function is used in example 2.\n"
17788 "\n"
17789 "\n"
17790 "\n"
17791 "SYNOPSIS:\n"
17792 "\n"
17793 "plhlsrgb(h, l, s, p_r, p_g, p_b)\n"
17794 "\n"
17795 "ARGUMENTS:\n"
17796 "\n"
17797 " h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n"
17798 " cylinder.\n"
17799 "\n"
17800 " l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n"
17801 " the axis of the color cylinder.\n"
17802 "\n"
17803 " s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n"
17804 " the radius of the color cylinder.\n"
17805 "\n"
17806 " p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n"
17807 " (0.0-1.0) of the color.\n"
17808 "\n"
17809 " p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n"
17810 " intensity (0.0-1.0) of the color.\n"
17811 "\n"
17812 " p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n"
17813 " intensity (0.0-1.0) of the color.\n"
17814 "\n"
17815 ""},
17816 { "plinit", _wrap_plinit, METH_NOARGS, "\n"
17817 "Initialize PLplot\n"
17818 "\n"
17819 "DESCRIPTION:\n"
17820 "\n"
17821 " Initializing the plotting package. The program prompts for the device\n"
17822 " keyword or number of the desired output device. Hitting a RETURN in\n"
17823 " response to the prompt is the same as selecting the first device.\n"
17824 " plinit will issue no prompt if either the device was specified\n"
17825 " previously (via command line flag, the plsetopt function, or the\n"
17826 " plsdev function), or if only one device is enabled when PLplot is\n"
17827 " installed. If subpages have been specified, the output device is\n"
17828 " divided into nx by ny subpages, each of which may be used\n"
17829 " independently. If plinit is called again during a program, the\n"
17830 " previously opened file will be closed. The subroutine pladv is used\n"
17831 " to advance from one subpage to the next.\n"
17832 "\n"
17833 " Redacted form: plinit()\n"
17834 "\n"
17835 " This function is used in all of the examples.\n"
17836 "\n"
17837 "\n"
17838 "\n"
17839 "SYNOPSIS:\n"
17840 "\n"
17841 "plinit()\n"
17842 "\n"
17843 ""},
17844 { "pljoin", _wrap_pljoin, METH_VARARGS, "\n"
17845 "Draw a line between two points\n"
17846 "\n"
17847 "DESCRIPTION:\n"
17848 "\n"
17849 " Joins the point (\n"
17850 " x1,\n"
17851 " y1) to (\n"
17852 " x2,\n"
17853 " y2).\n"
17854 "\n"
17855 " Redacted form: pljoin(x1,y1,x2,y2)\n"
17856 "\n"
17857 " This function is used in examples 3 and 14.\n"
17858 "\n"
17859 "\n"
17860 "\n"
17861 "SYNOPSIS:\n"
17862 "\n"
17863 "pljoin(x1, y1, x2, y2)\n"
17864 "\n"
17865 "ARGUMENTS:\n"
17866 "\n"
17867 " x1 (PLFLT, input) : x coordinate of first point.\n"
17868 "\n"
17869 " y1 (PLFLT, input) : y coordinate of first point.\n"
17870 "\n"
17871 " x2 (PLFLT, input) : x coordinate of second point.\n"
17872 "\n"
17873 " y2 (PLFLT, input) : y coordinate of second point.\n"
17874 "\n"
17875 ""},
17876 { "pllab", _wrap_pllab, METH_VARARGS, "\n"
17877 "Simple routine to write labels\n"
17878 "\n"
17879 "DESCRIPTION:\n"
17880 "\n"
17881 " Routine for writing simple labels. Use plmtex for more complex labels.\n"
17882 "\n"
17883 " Redacted form: pllab(xlabel, ylabel, tlabel)\n"
17884 "\n"
17885 " This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n"
17886 "\n"
17887 "\n"
17888 "\n"
17889 "SYNOPSIS:\n"
17890 "\n"
17891 "pllab(xlabel, ylabel, tlabel)\n"
17892 "\n"
17893 "ARGUMENTS:\n"
17894 "\n"
17895 " xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17896 " the label for the x axis.\n"
17897 "\n"
17898 " ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17899 " the label for the y axis.\n"
17900 "\n"
17901 " tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n"
17902 " the title of the plot.\n"
17903 "\n"
17904 ""},
17905 { "pllegend", _wrap_pllegend, METH_VARARGS, "\n"
17906 "Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n"
17907 "\n"
17908 "DESCRIPTION:\n"
17909 "\n"
17910 " Routine for creating a discrete plot legend with a plotted filled box,\n"
17911 " line, and/or line of symbols for each annotated legend entry. (See\n"
17912 " plcolorbar for similar functionality for creating continuous color\n"
17913 " bars.) The arguments of pllegend provide control over the location\n"
17914 " and size of the legend as well as the location and characteristics of\n"
17915 " the elements (most of which are optional) within that legend. The\n"
17916 " resulting legend is clipped at the boundaries of the current subpage.\n"
17917 " (N.B. the adopted coordinate system used for some of the parameters is\n"
17918 " defined in the documentation of the position parameter.)\n"
17919 "\n"
17920 " Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n"
17921 " position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n"
17922 " ncolumn, opt_array, text_offset, text_scale, text_spacing,\n"
17923 " test_justification, text_colors, text, box_colors, box_patterns,\n"
17924 " box_scales, box_line_widths, line_colors, line_styles, line_widths,\n"
17925 " symbol_colors, symbol_scales, symbol_numbers, symbols)\n"
17926 "\n"
17927 " This function is used in examples 4, 26, and 33.\n"
17928 "\n"
17929 "\n"
17930 "\n"
17931 "SYNOPSIS:\n"
17932 "\n"
17933 "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"
17934 "\n"
17935 "ARGUMENTS:\n"
17936 "\n"
17937 " p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17938 " legend width in adopted coordinates. This quantity is calculated\n"
17939 " from plot_width, text_offset, ncolumn (possibly modified inside\n"
17940 " the routine depending on nlegend and nrow), and the length\n"
17941 " (calculated internally) of the longest text string.\n"
17942 "\n"
17943 " p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
17944 " legend height in adopted coordinates. This quantity is calculated\n"
17945 " from text_scale, text_spacing, and nrow (possibly modified inside\n"
17946 " the routine depending on nlegend and nrow).\n"
17947 "\n"
17948 " opt (PLINT, input) : opt contains bits controlling the overall\n"
17949 " legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n"
17950 " on the left of the legend and the plotted area on the right.\n"
17951 " Otherwise, put the text area on the right of the legend and the\n"
17952 " plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n"
17953 " plot a (semitransparent) background for the legend. If the\n"
17954 " PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n"
17955 " legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n"
17956 " possibly internally transformed) nrow > 1 and ncolumn > 1, then\n"
17957 " plot the resulting array of legend entries in row-major order.\n"
17958 " Otherwise, plot the legend entries in column-major order.\n"
17959 "\n"
17960 " position (PLINT, input) : position contains bits which control the\n"
17961 " overall position of the legend and the definition of the adopted\n"
17962 " coordinates used for positions just like what is done for the\n"
17963 " position argument for plcolorbar. However, note that the defaults\n"
17964 " for the position bits (see below) are different than the\n"
17965 " plcolorbar case. The combination of the PL_POSITION_LEFT,\n"
17966 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
17967 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
17968 " the 16 possible standard positions (the 4 corners and centers of\n"
17969 " the 4 sides for both the inside and outside cases) of the legend\n"
17970 " relative to the adopted coordinate system. The corner positions\n"
17971 " are specified by the appropriate combination of two of the\n"
17972 " PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
17973 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
17974 " value of one of those bits. The adopted coordinates are\n"
17975 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
17976 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
17977 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
17978 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
17979 " then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n"
17980 " If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n"
17981 " use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n"
17982 " PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n"
17983 "\n"
17984 " x (PLFLT, input) : X offset of the legend position in adopted\n"
17985 " coordinates from the specified standard position of the legend.\n"
17986 " For positive x, the direction of motion away from the standard\n"
17987 " position is inward/outward from the standard corner positions or\n"
17988 " standard left or right positions if the\n"
17989 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
17990 " For the standard top or bottom positions, the direction of motion\n"
17991 " is toward positive X.\n"
17992 "\n"
17993 " y (PLFLT, input) : Y offset of the legend position in adopted\n"
17994 " coordinates from the specified standard position of the legend.\n"
17995 " For positive y, the direction of motion away from the standard\n"
17996 " position is inward/outward from the standard corner positions or\n"
17997 " standard top or bottom positions if the\n"
17998 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n"
17999 " the standard left or right positions, the direction of motion is\n"
18000 " toward positive Y.\n"
18001 "\n"
18002 " plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n"
18003 " of the plot area (where the colored boxes, lines, and/or lines of\n"
18004 " symbols are drawn) of the legend.\n"
18005 "\n"
18006 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18007 " legend (PL_LEGEND_BACKGROUND).\n"
18008 "\n"
18009 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18010 " for the legend (PL_LEGEND_BOUNDING_BOX).\n"
18011 "\n"
18012 " bb_style (PLINT, input) : The pllsty style number for the\n"
18013 " bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n"
18014 "\n"
18015 " nrow (PLINT, input) : The number of rows in the matrix used to\n"
18016 " render the\n"
18017 " nlegend legend entries. For internal transformations of\n"
18018 " nrow, see further remarks under\n"
18019 " nlegend.\n"
18020 "\n"
18021 " ncolumn (PLINT, input) : The number of columns in the matrix used\n"
18022 " to render the\n"
18023 " nlegend legend entries. For internal transformations of\n"
18024 " ncolumn, see further remarks under\n"
18025 " nlegend.\n"
18026 "\n"
18027 " nlegend (PLINT, input) : Number of legend entries. The above\n"
18028 " nrow and\n"
18029 " ncolumn values are transformed internally to be consistent with\n"
18030 " nlegend. If either\n"
18031 " nrow or\n"
18032 " ncolumn is non-positive it is replaced by 1. If the resulting product\n"
18033 " of\n"
18034 " nrow and\n"
18035 " ncolumn is less than\n"
18036 " nlegend, the smaller of the two (or\n"
18037 " nrow, if\n"
18038 " nrow ==\n"
18039 " ncolumn) is increased so the product is >=\n"
18040 " nlegend. Thus, for example, the common\n"
18041 " nrow = 0,\n"
18042 " ncolumn = 0 case is transformed internally to\n"
18043 " nrow =\n"
18044 " nlegend,\n"
18045 " ncolumn = 1; i.e., the usual case of a legend rendered as a single\n"
18046 " column.\n"
18047 "\n"
18048 " opt_array (PLINT_VECTOR, input) : A vector of\n"
18049 " nlegend values of options to control each individual plotted area\n"
18050 " corresponding to a legend entry. If the\n"
18051 " PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n"
18052 " area. If the\n"
18053 " PL_LEGEND_COLOR_BOX,\n"
18054 " PL_LEGEND_LINE, and/or\n"
18055 " PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n"
18056 " entry is plotted with a colored box; a line; and/or a line of\n"
18057 " symbols.\n"
18058 "\n"
18059 " text_offset (PLFLT, input) : Offset of the text area from the plot\n"
18060 " area in units of character width.\n"
18061 "\n"
18062 " text_scale (PLFLT, input) : Character height scale for text\n"
18063 " annotations.\n"
18064 "\n"
18065 " text_spacing (PLFLT, input) : Vertical spacing in units of the\n"
18066 " character height from one legend entry to the next.\n"
18067 "\n"
18068 " text_justification (PLFLT, input) : Justification parameter used\n"
18069 " for text justification. The most common values of\n"
18070 " text_justification are 0., 0.5, or 1. corresponding to a text that\n"
18071 " is left justified, centred, or right justified within the text\n"
18072 " area, but other values are allowed as well.\n"
18073 "\n"
18074 " text_colors (PLINT_VECTOR, input) : A vector containing\n"
18075 " nlegend cmap0 text colors.\n"
18076 "\n"
18077 " text (PLCHAR_MATRIX, input) : A vector of\n"
18078 " nlegend UTF-8 character strings containing the legend annotations.\n"
18079 "\n"
18080 " box_colors (PLINT_VECTOR, input) : A vector containing\n"
18081 " nlegend cmap0 colors for the discrete colored boxes (\n"
18082 " PL_LEGEND_COLOR_BOX).\n"
18083 "\n"
18084 " box_patterns (PLINT_VECTOR, input) : A vector containing\n"
18085 " nlegend patterns (plpsty indices) for the discrete colored boxes (\n"
18086 " PL_LEGEND_COLOR_BOX).\n"
18087 "\n"
18088 " box_scales (PLFLT_VECTOR, input) : A vector containing\n"
18089 " nlegend scales (units of fraction of character height) for the height\n"
18090 " of the discrete colored boxes (\n"
18091 " PL_LEGEND_COLOR_BOX).\n"
18092 "\n"
18093 " box_line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18094 " nlegend line widths for the patterns specified by box_patterns (\n"
18095 " PL_LEGEND_COLOR_BOX).\n"
18096 "\n"
18097 " line_colors (PLINT_VECTOR, input) : A vector containing\n"
18098 " nlegend cmap0 line colors (\n"
18099 " PL_LEGEND_LINE).\n"
18100 "\n"
18101 " line_styles (PLINT_VECTOR, input) : A vector containing\n"
18102 " nlegend line styles (plsty indices) (\n"
18103 " PL_LEGEND_LINE).\n"
18104 "\n"
18105 " line_widths (PLFLT_VECTOR, input) : A vector containing\n"
18106 " nlegend line widths (\n"
18107 " PL_LEGEND_LINE).\n"
18108 "\n"
18109 " symbol_colors (PLINT_VECTOR, input) : A vector containing\n"
18110 " nlegend cmap0 symbol colors (\n"
18111 " PL_LEGEND_SYMBOL).\n"
18112 "\n"
18113 " symbol_scales (PLFLT_VECTOR, input) : A vector containing\n"
18114 " nlegend scale values for the symbol height (\n"
18115 " PL_LEGEND_SYMBOL).\n"
18116 "\n"
18117 " symbol_numbers (PLINT_VECTOR, input) : A vector containing\n"
18118 " nlegend numbers of symbols to be drawn across the width of the plotted\n"
18119 " area (\n"
18120 " PL_LEGEND_SYMBOL).\n"
18121 "\n"
18122 " symbols (PLCHAR_MATRIX, input) : A vector of\n"
18123 " nlegend UTF-8 character strings containing the legend symbols. (\n"
18124 " PL_LEGEND_SYMBOL).\n"
18125 "\n"
18126 ""},
18127 { "plcolorbar", _wrap_plcolorbar, METH_VARARGS, "\n"
18128 "Plot color bar for image, shade or gradient plots\n"
18129 "\n"
18130 "DESCRIPTION:\n"
18131 "\n"
18132 " Routine for creating a continuous color bar for image, shade, or\n"
18133 " gradient plots. (See pllegend for similar functionality for creating\n"
18134 " legends with discrete elements). The arguments of plcolorbar provide\n"
18135 " control over the location and size of the color bar as well as the\n"
18136 " location and characteristics of the elements (most of which are\n"
18137 " optional) within that color bar. The resulting color bar is clipped\n"
18138 " at the boundaries of the current subpage. (N.B. the adopted coordinate\n"
18139 " system used for some of the parameters is defined in the documentation\n"
18140 " of the position parameter.)\n"
18141 "\n"
18142 " Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n"
18143 " position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n"
18144 " low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n"
18145 " labels, axis_opts, ticks, sub_ticks, values)\n"
18146 "\n"
18147 " This function is used in examples 16 and 33.\n"
18148 "\n"
18149 "\n"
18150 "\n"
18151 "SYNOPSIS:\n"
18152 "\n"
18153 "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"
18154 "\n"
18155 "ARGUMENTS:\n"
18156 "\n"
18157 " p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18158 " labelled and decorated color bar width in adopted coordinates.\n"
18159 "\n"
18160 " p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n"
18161 " labelled and decorated color bar height in adopted coordinates.\n"
18162 "\n"
18163 " opt (PLINT, input) : opt contains bits controlling the overall\n"
18164 " color bar. The orientation (direction of the maximum value) of\n"
18165 " the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n"
18166 " PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n"
18167 " specified, the default orientation is toward the top if the\n"
18168 " colorbar is placed on the left or right of the viewport or toward\n"
18169 " the right if the colorbar is placed on the top or bottom of the\n"
18170 " viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n"
18171 " (semitransparent) background for the color bar. If the\n"
18172 " PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n"
18173 " color bar. The type of color bar must be specified with one of\n"
18174 " PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n"
18175 " more than one of those bits is set only the first one in the above\n"
18176 " list is honored. The position of the (optional) label/title can be\n"
18177 " specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n"
18178 " PL_LABEL_BOTTOM. If no label position bit is set then no label\n"
18179 " will be drawn. If more than one of this list of bits is specified,\n"
18180 " only the first one on the list is honored. End-caps for the color\n"
18181 " bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n"
18182 " If a particular color bar cap option is not specified then no cap\n"
18183 " will be drawn for that end. As a special case for\n"
18184 " PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n"
18185 " specified. If this option is provided then any tick marks and tick\n"
18186 " labels will be placed at the breaks between shaded segments. TODO:\n"
18187 " This should be expanded to support custom placement of tick marks\n"
18188 " and tick labels at custom value locations for any color bar type.\n"
18189 "\n"
18190 " position (PLINT, input) : position contains bits which control the\n"
18191 " overall position of the color bar and the definition of the\n"
18192 " adopted coordinates used for positions just like what is done for\n"
18193 " the position argument for pllegend. However, note that the\n"
18194 " defaults for the position bits (see below) are different than the\n"
18195 " pllegend case. The combination of the PL_POSITION_LEFT,\n"
18196 " PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n"
18197 " PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n"
18198 " the 16 possible standard positions (the 4 corners and centers of\n"
18199 " the 4 sides for both the inside and outside cases) of the color\n"
18200 " bar relative to the adopted coordinate system. The corner\n"
18201 " positions are specified by the appropriate combination of two of\n"
18202 " the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n"
18203 " PL_POSITION_BOTTOM bits while the sides are specified by a single\n"
18204 " value of one of those bits. The adopted coordinates are\n"
18205 " normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n"
18206 " set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n"
18207 " bit is set. Default position bits: If none of PL_POSITION_LEFT,\n"
18208 " PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n"
18209 " then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n"
18210 " PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n"
18211 " PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n"
18212 " PL_POSITION_VIEWPORT.\n"
18213 "\n"
18214 " x (PLFLT, input) : X offset of the color bar position in adopted\n"
18215 " coordinates from the specified standard position of the color bar.\n"
18216 " For positive x, the direction of motion away from the standard\n"
18217 " position is inward/outward from the standard corner positions or\n"
18218 " standard left or right positions if the\n"
18219 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18220 " For the standard top or bottom positions, the direction of motion\n"
18221 " is toward positive X.\n"
18222 "\n"
18223 " y (PLFLT, input) : Y offset of the color bar position in adopted\n"
18224 " coordinates from the specified standard position of the color bar.\n"
18225 " For positive y, the direction of motion away from the standard\n"
18226 " position is inward/outward from the standard corner positions or\n"
18227 " standard top or bottom positions if the\n"
18228 " PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n"
18229 " For the standard left or right positions, the direction of motion\n"
18230 " is toward positive Y.\n"
18231 "\n"
18232 " x_length (PLFLT, input) : Length of the body of the color bar in\n"
18233 " the X direction in adopted coordinates.\n"
18234 "\n"
18235 " y_length (PLFLT, input) : Length of the body of the color bar in\n"
18236 " the Y direction in adopted coordinates.\n"
18237 "\n"
18238 " bg_color (PLINT, input) : The cmap0 color of the background for the\n"
18239 " color bar (PL_COLORBAR_BACKGROUND).\n"
18240 "\n"
18241 " bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n"
18242 " for the color bar (PL_COLORBAR_BOUNDING_BOX).\n"
18243 "\n"
18244 " bb_style (PLINT, input) : The pllsty style number for the\n"
18245 " bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n"
18246 "\n"
18247 " low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n"
18248 " bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n"
18249 "\n"
18250 " high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n"
18251 " color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n"
18252 "\n"
18253 " cont_color (PLINT, input) : The cmap0 contour color for\n"
18254 " PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n"
18255 " it will be interpreted according to the design of plshades.\n"
18256 "\n"
18257 " cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n"
18258 " plots. This is passed directly to plshades, so it will be\n"
18259 " interpreted according to the design of plshades.\n"
18260 "\n"
18261 " n_labels (PLINT, input) : Number of labels to place around the\n"
18262 " color bar.\n"
18263 "\n"
18264 " label_opts (PLINT_VECTOR, input) : A vector of options for each of\n"
18265 " n_labels labels.\n"
18266 "\n"
18267 " labels (PLCHAR_MATRIX, input) : A vector of\n"
18268 " n_labels UTF-8 character strings containing the labels for the color\n"
18269 " bar. Ignored if no label position is specified with one of the\n"
18270 " PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n"
18271 " PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n"
18272 " corresponding label_opts field.\n"
18273 "\n"
18274 " n_axes (PLINT, input) : Number of axis definitions provided. This\n"
18275 " value must be greater than 0. It is typically 1 (numerical axis\n"
18276 " labels are provided for one of the long edges of the color bar),\n"
18277 " but it can be larger if multiple numerical axis labels for the\n"
18278 " long edges of the color bar are desired.\n"
18279 "\n"
18280 " axis_opts (PLCHAR_MATRIX, input) : A vector of\n"
18281 " n_axes ascii character strings containing options (interpreted as for\n"
18282 " plbox) for the color bar's axis definitions.\n"
18283 "\n"
18284 " ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n"
18285 " spacing of the major tick marks (interpreted as for plbox) for the\n"
18286 " color bar's axis definitions.\n"
18287 "\n"
18288 " sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n"
18289 " number of subticks (interpreted as for plbox) for the color bar's\n"
18290 " axis definitions.\n"
18291 "\n"
18292 " n_values (PLINT_VECTOR, input) : A vector containing the number of\n"
18293 " elements in each of the n_axes rows of the values matrix.\n"
18294 "\n"
18295 " values (PLFLT_MATRIX, input) : A matrix containing the numeric\n"
18296 " values for the data range represented by the color bar. For a row\n"
18297 " index of i_axis (where 0 < i_axis < n_axes), the number of\n"
18298 " elements in the row is specified by n_values[i_axis]. For\n"
18299 " PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n"
18300 " is 2, and the corresponding row elements of the values matrix are\n"
18301 " the minimum and maximum value represented by the colorbar. For\n"
18302 " PL_COLORBAR_SHADE, the number and values of the elements of a row\n"
18303 " of the values matrix is interpreted the same as the nlevel and\n"
18304 " clevel arguments of plshades.\n"
18305 "\n"
18306 ""},
18307 { "pllightsource", _wrap_pllightsource, METH_VARARGS, "\n"
18308 "Sets the 3D position of the light source\n"
18309 "\n"
18310 "DESCRIPTION:\n"
18311 "\n"
18312 " Sets the 3D position of the light source for use with plsurf3d and\n"
18313 " plsurf3dl\n"
18314 "\n"
18315 " Redacted form: pllightsource(x, y, z)\n"
18316 "\n"
18317 " This function is used in example 8.\n"
18318 "\n"
18319 "\n"
18320 "\n"
18321 "SYNOPSIS:\n"
18322 "\n"
18323 "pllightsource(x, y, z)\n"
18324 "\n"
18325 "ARGUMENTS:\n"
18326 "\n"
18327 " x (PLFLT, input) : X-coordinate of the light source.\n"
18328 "\n"
18329 " y (PLFLT, input) : Y-coordinate of the light source.\n"
18330 "\n"
18331 " z (PLFLT, input) : Z-coordinate of the light source.\n"
18332 "\n"
18333 ""},
18334 { "plline", _wrap_plline, METH_VARARGS, "\n"
18335 "Draw a line\n"
18336 "\n"
18337 "DESCRIPTION:\n"
18338 "\n"
18339 " Draws line defined by n points in x and y.\n"
18340 "\n"
18341 " Redacted form: plline(x, y)\n"
18342 "\n"
18343 " This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n"
18344 " 25-27, and 29.\n"
18345 "\n"
18346 "\n"
18347 "\n"
18348 "SYNOPSIS:\n"
18349 "\n"
18350 "plline(n, x, y)\n"
18351 "\n"
18352 "ARGUMENTS:\n"
18353 "\n"
18354 " n (PLINT, input) : Number of points defining line.\n"
18355 "\n"
18356 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18357 " points.\n"
18358 "\n"
18359 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18360 " points.\n"
18361 "\n"
18362 ""},
18363 { "plline3", _wrap_plline3, METH_VARARGS, "\n"
18364 "Draw a line in 3 space\n"
18365 "\n"
18366 "DESCRIPTION:\n"
18367 "\n"
18368 " Draws line in 3 space defined by n points in x, y, and z. You must\n"
18369 " first set up the viewport, the 2d viewing window (in world\n"
18370 " coordinates), and the 3d normalized coordinate box. See x18c.c for\n"
18371 " more info.\n"
18372 "\n"
18373 " Redacted form: plline3(x, y, z)\n"
18374 "\n"
18375 " This function is used in example 18.\n"
18376 "\n"
18377 "\n"
18378 "\n"
18379 "SYNOPSIS:\n"
18380 "\n"
18381 "plline3(n, x, y, z)\n"
18382 "\n"
18383 "ARGUMENTS:\n"
18384 "\n"
18385 " n (PLINT, input) : Number of points defining line.\n"
18386 "\n"
18387 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
18388 " points.\n"
18389 "\n"
18390 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
18391 " points.\n"
18392 "\n"
18393 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
18394 " points.\n"
18395 "\n"
18396 ""},
18397 { "pllsty", _wrap_pllsty, METH_O, "\n"
18398 "Select line style\n"
18399 "\n"
18400 "DESCRIPTION:\n"
18401 "\n"
18402 " This sets the line style according to one of eight predefined patterns\n"
18403 " (also see plstyl).\n"
18404 "\n"
18405 " Redacted form: pllsty(lin)\n"
18406 "\n"
18407 " This function is used in examples 9, 12, 22, and 25.\n"
18408 "\n"
18409 "\n"
18410 "\n"
18411 "SYNOPSIS:\n"
18412 "\n"
18413 "pllsty(lin)\n"
18414 "\n"
18415 "ARGUMENTS:\n"
18416 "\n"
18417 " lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n"
18418 " a continuous line, line style 2 is a line with short dashes and\n"
18419 " gaps, line style 3 is a line with long dashes and gaps, line style\n"
18420 " 4 has long dashes and short gaps and so on.\n"
18421 "\n"
18422 ""},
18423 { "plmesh", _wrap_plmesh, METH_VARARGS, "\n"
18424 "Plot surface mesh\n"
18425 "\n"
18426 "DESCRIPTION:\n"
18427 "\n"
18428 " Plots a surface mesh within the environment set up by plw3d. The\n"
18429 " surface is defined by the matrix z[\n"
18430 " nx][\n"
18431 " ny] , the point z[i][j] being the value of the function at (\n"
18432 " x[i],\n"
18433 " y[j]). Note that the points in vectors x and y do not need to be\n"
18434 " equally spaced, but must be stored in ascending order. The parameter\n"
18435 " opt controls the way in which the surface is displayed. For further\n"
18436 " details see the PLplot documentation.\n"
18437 "\n"
18438 " Redacted form: plmesh(x, y, z, opt)\n"
18439 "\n"
18440 " This function is used in example 11.\n"
18441 "\n"
18442 "\n"
18443 "\n"
18444 "SYNOPSIS:\n"
18445 "\n"
18446 "plmesh(x, y, z, nx, ny, opt)\n"
18447 "\n"
18448 "ARGUMENTS:\n"
18449 "\n"
18450 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18451 " which the function is evaluated.\n"
18452 "\n"
18453 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18454 " which the function is evaluated.\n"
18455 "\n"
18456 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18457 " plot. Should have dimensions of\n"
18458 " nx by\n"
18459 " ny.\n"
18460 "\n"
18461 " nx (PLINT, input) : Number of x values at which function has been\n"
18462 " evaluated.\n"
18463 "\n"
18464 " ny (PLINT, input) : Number of y values at which function has been\n"
18465 " evaluated.\n"
18466 "\n"
18467 " opt (PLINT, input) : Determines the way in which the surface is\n"
18468 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18469 " function of x for each value of y[j] .\n"
18470 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18471 " for each value of x[i] .\n"
18472 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18473 " at which function is defined.\n"
18474 "\n"
18475 ""},
18476 { "plmeshc", _wrap_plmeshc, METH_VARARGS, "\n"
18477 "Magnitude colored plot surface mesh with contour\n"
18478 "\n"
18479 "DESCRIPTION:\n"
18480 "\n"
18481 " A more powerful form of plmesh: the surface mesh can be colored\n"
18482 " accordingly to the current z value being plotted, a contour plot can\n"
18483 " be drawn at the base XY plane, and a curtain can be drawn between the\n"
18484 " plotted function border and the base XY plane.\n"
18485 "\n"
18486 " Redacted form: plmeshc(x, y, z, opt, clevel)\n"
18487 "\n"
18488 " This function is used in example 11.\n"
18489 "\n"
18490 "\n"
18491 "\n"
18492 "SYNOPSIS:\n"
18493 "\n"
18494 "plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18495 "\n"
18496 "ARGUMENTS:\n"
18497 "\n"
18498 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18499 " which the function is evaluated.\n"
18500 "\n"
18501 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18502 " which the function is evaluated.\n"
18503 "\n"
18504 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18505 " plot. Should have dimensions of\n"
18506 " nx by\n"
18507 " ny.\n"
18508 "\n"
18509 " nx (PLINT, input) : Number of x values at which function is\n"
18510 " evaluated.\n"
18511 "\n"
18512 " ny (PLINT, input) : Number of y values at which function is\n"
18513 " evaluated.\n"
18514 "\n"
18515 " opt (PLINT, input) : Determines the way in which the surface is\n"
18516 " represented. To specify more than one option just add the options,\n"
18517 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18518 " showing z as a function of x for each value of y[j] .\n"
18519 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18520 " for each value of x[i] .\n"
18521 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18522 " at which function is defined.\n"
18523 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18524 " the z value being plotted. The color is used from the current\n"
18525 " cmap1.\n"
18526 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18527 " using parameters\n"
18528 " nlevel and\n"
18529 " clevel.\n"
18530 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18531 " the borders of the plotted function.\n"
18532 "\n"
18533 "\n"
18534 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18535 " levels.\n"
18536 "\n"
18537 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18538 "\n"
18539 ""},
18540 { "plmkstrm", _wrap_plmkstrm, METH_NOARGS, "\n"
18541 "Creates a new stream and makes it the default\n"
18542 "\n"
18543 "DESCRIPTION:\n"
18544 "\n"
18545 " Creates a new stream and makes it the default. Differs from using\n"
18546 " plsstrm, in that a free stream number is found, and returned.\n"
18547 " Unfortunately, I have to start at stream 1 and work upward, since\n"
18548 " stream 0 is preallocated. One of the big flaws in the PLplot API is\n"
18549 " that no initial, library-opening call is required. So stream 0 must\n"
18550 " be preallocated, and there is no simple way of determining whether it\n"
18551 " is already in use or not.\n"
18552 "\n"
18553 " Redacted form: plmkstrm(p_strm)\n"
18554 "\n"
18555 " This function is used in examples 1 and 20.\n"
18556 "\n"
18557 "\n"
18558 "\n"
18559 "SYNOPSIS:\n"
18560 "\n"
18561 "plmkstrm(p_strm)\n"
18562 "\n"
18563 "ARGUMENTS:\n"
18564 "\n"
18565 " p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n"
18566 " number of the created stream.\n"
18567 "\n"
18568 ""},
18569 { "plmtex", _wrap_plmtex, METH_VARARGS, "\n"
18570 "Write text relative to viewport boundaries\n"
18571 "\n"
18572 "DESCRIPTION:\n"
18573 "\n"
18574 " Writes text at a specified position relative to the viewport\n"
18575 " boundaries. Text may be written inside or outside the viewport, but\n"
18576 " is clipped at the subpage boundaries. The reference point of a string\n"
18577 " lies along a line passing through the string at half the height of a\n"
18578 " capital letter. The position of the reference point along this line\n"
18579 " is determined by just, and the position of the reference point\n"
18580 " relative to the viewport is set by disp and pos.\n"
18581 "\n"
18582 " Redacted form: General: plmtex(side, disp, pos, just, text)\n"
18583 "\n"
18584 "\n"
18585 " This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n"
18586 " 26.\n"
18587 "\n"
18588 "\n"
18589 "\n"
18590 "SYNOPSIS:\n"
18591 "\n"
18592 "plmtex(side, disp, pos, just, text)\n"
18593 "\n"
18594 "ARGUMENTS:\n"
18595 "\n"
18596 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18597 " the side of the viewport along which the text is to be written.\n"
18598 " The string must be one of: b: Bottom of viewport, text written\n"
18599 " parallel to edge.\n"
18600 " bv: Bottom of viewport, text written at right angles to edge.\n"
18601 " l: Left of viewport, text written parallel to edge.\n"
18602 " lv: Left of viewport, text written at right angles to edge.\n"
18603 " r: Right of viewport, text written parallel to edge.\n"
18604 " rv: Right of viewport, text written at right angles to edge.\n"
18605 " t: Top of viewport, text written parallel to edge.\n"
18606 " tv: Top of viewport, text written at right angles to edge.\n"
18607 "\n"
18608 "\n"
18609 " disp (PLFLT, input) : Position of the reference point of string,\n"
18610 " measured outwards from the specified viewport edge in units of the\n"
18611 " current character height. Use negative disp to write within the\n"
18612 " viewport.\n"
18613 "\n"
18614 " pos (PLFLT, input) : Position of the reference point of string\n"
18615 " along the specified edge, expressed as a fraction of the length of\n"
18616 " the edge.\n"
18617 "\n"
18618 " just (PLFLT, input) : Specifies the position of the string relative\n"
18619 " to its reference point. If just=0. , the reference point is at\n"
18620 " the left and if just=1. , it is at the right of the string. Other\n"
18621 " values of just give intermediate justifications.\n"
18622 "\n"
18623 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18624 " written out.\n"
18625 "\n"
18626 ""},
18627 { "plmtex3", _wrap_plmtex3, METH_VARARGS, "\n"
18628 "Write text relative to viewport boundaries in 3D plots\n"
18629 "\n"
18630 "DESCRIPTION:\n"
18631 "\n"
18632 " Writes text at a specified position relative to the viewport\n"
18633 " boundaries. Text may be written inside or outside the viewport, but\n"
18634 " is clipped at the subpage boundaries. The reference point of a string\n"
18635 " lies along a line passing through the string at half the height of a\n"
18636 " capital letter. The position of the reference point along this line\n"
18637 " is determined by just, and the position of the reference point\n"
18638 " relative to the viewport is set by disp and pos.\n"
18639 "\n"
18640 " Redacted form: plmtex3(side, disp, pos, just, text)\n"
18641 "\n"
18642 " This function is used in example 28.\n"
18643 "\n"
18644 "\n"
18645 "\n"
18646 "SYNOPSIS:\n"
18647 "\n"
18648 "plmtex3(side, disp, pos, just, text)\n"
18649 "\n"
18650 "ARGUMENTS:\n"
18651 "\n"
18652 " side (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
18653 " the side of the viewport along which the text is to be written.\n"
18654 " The string should contain one or more of the following characters:\n"
18655 " [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n"
18656 " only label the X axis, not both the X and Y axes. x: Label the X\n"
18657 " axis.\n"
18658 " y: Label the Y axis.\n"
18659 " z: Label the Z axis.\n"
18660 " p: Label the primary axis. For Z this is the leftmost Z axis.\n"
18661 " For X it is the axis that starts at y-min. For Y it is the\n"
18662 " axis that starts at x-min.\n"
18663 " s: Label the secondary axis.\n"
18664 " v: Draw the text perpendicular to the axis.\n"
18665 "\n"
18666 "\n"
18667 " disp (PLFLT, input) : Position of the reference point of string,\n"
18668 " measured outwards from the specified viewport edge in units of the\n"
18669 " current character height. Use negative disp to write within the\n"
18670 " viewport.\n"
18671 "\n"
18672 " pos (PLFLT, input) : Position of the reference point of string\n"
18673 " along the specified edge, expressed as a fraction of the length of\n"
18674 " the edge.\n"
18675 "\n"
18676 " just (PLFLT, input) : Specifies the position of the string relative\n"
18677 " to its reference point. If just=0. , the reference point is at\n"
18678 " the left and if just=1. , it is at the right of the string. Other\n"
18679 " values of just give intermediate justifications.\n"
18680 "\n"
18681 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
18682 " written out.\n"
18683 "\n"
18684 ""},
18685 { "plot3d", _wrap_plot3d, METH_VARARGS, "\n"
18686 "Plot 3-d surface plot\n"
18687 "\n"
18688 "DESCRIPTION:\n"
18689 "\n"
18690 " Plots a three-dimensional surface plot within the environment set up\n"
18691 " by plw3d. The surface is defined by the matrix z[\n"
18692 " nx][\n"
18693 " ny] , the point z[i][j] being the value of the function at (\n"
18694 " x[i],\n"
18695 " y[j]). Note that the points in vectors x and y do not need to be\n"
18696 " equally spaced, but must be stored in ascending order. The parameter\n"
18697 " opt controls the way in which the surface is displayed. For further\n"
18698 " details see the PLplot documentation. The only difference between\n"
18699 " plmesh and plot3d is that plmesh draws the bottom side of the surface,\n"
18700 " while plot3d only draws the surface as viewed from the top.\n"
18701 "\n"
18702 " Redacted form: plot3d(x, y, z, opt, side)\n"
18703 "\n"
18704 " This function is used in examples 11 and 21.\n"
18705 "\n"
18706 "\n"
18707 "\n"
18708 "SYNOPSIS:\n"
18709 "\n"
18710 "plot3d(x, y, z, nx, ny, opt, side)\n"
18711 "\n"
18712 "ARGUMENTS:\n"
18713 "\n"
18714 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18715 " which the function is evaluated.\n"
18716 "\n"
18717 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18718 " which the function is evaluated.\n"
18719 "\n"
18720 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18721 " plot. Should have dimensions of\n"
18722 " nx by\n"
18723 " ny.\n"
18724 "\n"
18725 " nx (PLINT, input) : Number of x values at which function is\n"
18726 " evaluated.\n"
18727 "\n"
18728 " ny (PLINT, input) : Number of y values at which function is\n"
18729 " evaluated.\n"
18730 "\n"
18731 " opt (PLINT, input) : Determines the way in which the surface is\n"
18732 " represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n"
18733 " function of x for each value of y[j] .\n"
18734 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18735 " for each value of x[i] .\n"
18736 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18737 " at which function is defined.\n"
18738 "\n"
18739 "\n"
18740 " side (PLBOOL, input) : Flag to indicate whether or not ``sides''\n"
18741 " should be draw on the figure. If side is true sides are drawn,\n"
18742 " otherwise no sides are drawn.\n"
18743 "\n"
18744 ""},
18745 { "plot3dc", _wrap_plot3dc, METH_VARARGS, "\n"
18746 "Magnitude colored plot surface with contour\n"
18747 "\n"
18748 "DESCRIPTION:\n"
18749 "\n"
18750 " Aside from dropping the\n"
18751 " side functionality this is a more powerful form of plot3d: the surface\n"
18752 " mesh can be colored accordingly to the current z value being plotted,\n"
18753 " a contour plot can be drawn at the base XY plane, and a curtain can be\n"
18754 " drawn between the plotted function border and the base XY plane. The\n"
18755 " arguments are identical to those of plmeshc. The only difference\n"
18756 " between plmeshc and plot3dc is that plmeshc draws the bottom side of\n"
18757 " the surface, while plot3dc only draws the surface as viewed from the\n"
18758 " top.\n"
18759 "\n"
18760 " Redacted form: General: plot3dc(x, y, z, opt, clevel)\n"
18761 "\n"
18762 "\n"
18763 " This function is used in example 21.\n"
18764 "\n"
18765 "\n"
18766 "\n"
18767 "SYNOPSIS:\n"
18768 "\n"
18769 "plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18770 "\n"
18771 "ARGUMENTS:\n"
18772 "\n"
18773 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18774 " which the function is evaluated.\n"
18775 "\n"
18776 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18777 " which the function is evaluated.\n"
18778 "\n"
18779 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18780 " plot. Should have dimensions of\n"
18781 " nx by\n"
18782 " ny.\n"
18783 "\n"
18784 " nx (PLINT, input) : Number of x values at which function is\n"
18785 " evaluated.\n"
18786 "\n"
18787 " ny (PLINT, input) : Number of y values at which function is\n"
18788 " evaluated.\n"
18789 "\n"
18790 " opt (PLINT, input) : Determines the way in which the surface is\n"
18791 " represented. To specify more than one option just add the options,\n"
18792 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18793 " showing z as a function of x for each value of y[j] .\n"
18794 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18795 " for each value of x[i] .\n"
18796 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18797 " at which function is defined.\n"
18798 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18799 " the z value being plotted. The color is used from the current\n"
18800 " cmap1.\n"
18801 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18802 " using parameters\n"
18803 " nlevel and\n"
18804 " clevel.\n"
18805 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18806 " the borders of the plotted function.\n"
18807 "\n"
18808 "\n"
18809 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18810 " levels.\n"
18811 "\n"
18812 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18813 "\n"
18814 ""},
18815 { "plot3dcl", _wrap_plot3dcl, METH_VARARGS, "\n"
18816 "Magnitude colored plot surface with contour for z[x][y] with y index limits\n"
18817 "\n"
18818 "DESCRIPTION:\n"
18819 "\n"
18820 " When the implementation is completed this variant of plot3dc (see that\n"
18821 " function's documentation for more details) should be suitable for the\n"
18822 " case where the area of the x, y coordinate grid where z is defined can\n"
18823 " be non-rectangular. The implementation is incomplete so the last 4\n"
18824 " parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n"
18825 " indexymax; are currently ignored and the functionality is otherwise\n"
18826 " identical to that of plot3dc.\n"
18827 "\n"
18828 " Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n"
18829 " indexymin, indexymax)\n"
18830 "\n"
18831 "\n"
18832 " This function is not used in any example.\n"
18833 "\n"
18834 "\n"
18835 "\n"
18836 "SYNOPSIS:\n"
18837 "\n"
18838 "plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18839 "\n"
18840 "ARGUMENTS:\n"
18841 "\n"
18842 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18843 " which the function is evaluated.\n"
18844 "\n"
18845 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18846 " which the function is evaluated.\n"
18847 "\n"
18848 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18849 " plot. Should have dimensions of\n"
18850 " nx by\n"
18851 " ny.\n"
18852 "\n"
18853 " nx (PLINT, input) : Number of x values at which the function is\n"
18854 " evaluated.\n"
18855 "\n"
18856 " ny (PLINT, input) : Number of y values at which the function is\n"
18857 " evaluated.\n"
18858 "\n"
18859 " opt (PLINT, input) : Determines the way in which the surface is\n"
18860 " represented. To specify more than one option just add the options,\n"
18861 " e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n"
18862 " showing z as a function of x for each value of y[j] .\n"
18863 " opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n"
18864 " for each value of x[i] .\n"
18865 " opt=DRAW_LINEXY : Network of lines is drawn connecting points\n"
18866 " at which function is defined.\n"
18867 " opt=MAG_COLOR : Each line in the mesh is colored according to\n"
18868 " the z value being plotted. The color is used from the current\n"
18869 " cmap1.\n"
18870 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18871 " using parameters\n"
18872 " nlevel and\n"
18873 " clevel.\n"
18874 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18875 " the borders of the plotted function.\n"
18876 "\n"
18877 "\n"
18878 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18879 " levels.\n"
18880 "\n"
18881 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18882 "\n"
18883 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
18884 " corresponds to the first x index where z is defined.\n"
18885 "\n"
18886 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
18887 " which corresponds (by convention) to one more than the last x\n"
18888 " index value where z is defined.\n"
18889 "\n"
18890 " indexymin (PLINT_VECTOR, input) : A vector containing y index\n"
18891 " values which all must be ≥ 0. These values are the first y index\n"
18892 " where z is defined for a particular x index in the range from\n"
18893 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
18894 " indexxmax.\n"
18895 "\n"
18896 " indexymax (PLINT_VECTOR, input) : A vector containing y index\n"
18897 " values which all must be ≤ ny. These values correspond (by\n"
18898 " convention) to one more than the last y index where z is defined\n"
18899 " for a particular x index in the range from indexxmin to indexxmax\n"
18900 " - 1. The dimension of indexymax is indexxmax.\n"
18901 "\n"
18902 ""},
18903 { "plsurf3d", _wrap_plsurf3d, METH_VARARGS, "\n"
18904 "Plot shaded 3-d surface plot\n"
18905 "\n"
18906 "DESCRIPTION:\n"
18907 "\n"
18908 " Plots a three-dimensional shaded surface plot within the environment\n"
18909 " set up by plw3d. The surface is defined by the two-dimensional matrix\n"
18910 " z[\n"
18911 " nx][\n"
18912 " ny], the point z[i][j] being the value of the function at (\n"
18913 " x[i],\n"
18914 " y[j]). Note that the points in vectors x and y do not need to be\n"
18915 " equally spaced, but must be stored in ascending order. For further\n"
18916 " details see the PLplot documentation.\n"
18917 "\n"
18918 " Redacted form: plsurf3d(x, y, z, opt, clevel)\n"
18919 "\n"
18920 " This function is not used in any examples.\n"
18921 "\n"
18922 "\n"
18923 "\n"
18924 "SYNOPSIS:\n"
18925 "\n"
18926 "plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n"
18927 "\n"
18928 "ARGUMENTS:\n"
18929 "\n"
18930 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18931 " which the function is evaluated.\n"
18932 "\n"
18933 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
18934 " which the function is evaluated.\n"
18935 "\n"
18936 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
18937 " plot. Should have dimensions of\n"
18938 " nx by\n"
18939 " ny.\n"
18940 "\n"
18941 " nx (PLINT, input) : Number of x values at which function is\n"
18942 " evaluated.\n"
18943 "\n"
18944 " ny (PLINT, input) : Number of y values at which function is\n"
18945 " evaluated.\n"
18946 "\n"
18947 " opt (PLINT, input) : Determines the way in which the surface is\n"
18948 " represented. To specify more than one option just add the options,\n"
18949 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
18950 " connecting points at which function is defined.\n"
18951 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
18952 " using parameters\n"
18953 " nlevel and\n"
18954 " clevel.\n"
18955 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
18956 " using parameters\n"
18957 " nlevel and\n"
18958 " clevel.\n"
18959 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
18960 " the borders of the plotted function.\n"
18961 " opt=MAG_COLOR : the surface is colored according to the value\n"
18962 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
18963 " according to the intensity of the reflected light in the\n"
18964 " surface from a light source whose position is set using\n"
18965 " pllightsource.\n"
18966 "\n"
18967 "\n"
18968 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
18969 " levels.\n"
18970 "\n"
18971 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
18972 "\n"
18973 ""},
18974 { "plsurf3dl", _wrap_plsurf3dl, METH_VARARGS, "\n"
18975 "Plot shaded 3-d surface plot for z[x][y] with y index limits\n"
18976 "\n"
18977 "DESCRIPTION:\n"
18978 "\n"
18979 " This variant of plsurf3d (see that function's documentation for more\n"
18980 " details) should be suitable for the case where the area of the x, y\n"
18981 " coordinate grid where z is defined can be non-rectangular. The limits\n"
18982 " of that grid are provided by the parameters indexxmin, indexxmax,\n"
18983 " indexymin, and indexymax.\n"
18984 "\n"
18985 " Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n"
18986 " indexymax)\n"
18987 "\n"
18988 " This function is used in example 8.\n"
18989 "\n"
18990 "\n"
18991 "\n"
18992 "SYNOPSIS:\n"
18993 "\n"
18994 "plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n"
18995 "\n"
18996 "ARGUMENTS:\n"
18997 "\n"
18998 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n"
18999 " which the function is evaluated.\n"
19000 "\n"
19001 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n"
19002 " which the function is evaluated.\n"
19003 "\n"
19004 " z (PLFLT_MATRIX, input) : A matrix containing function values to\n"
19005 " plot. Should have dimensions of\n"
19006 " nx by\n"
19007 " ny.\n"
19008 "\n"
19009 " nx (PLINT, input) : Number of x values at which function is\n"
19010 " evaluated.\n"
19011 "\n"
19012 " ny (PLINT, input) : Number of y values at which function is\n"
19013 " evaluated.\n"
19014 "\n"
19015 " opt (PLINT, input) : Determines the way in which the surface is\n"
19016 " represented. To specify more than one option just add the options,\n"
19017 " e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n"
19018 " connecting points at which function is defined.\n"
19019 " opt=BASE_CONT : A contour plot is drawn at the base XY plane\n"
19020 " using parameters\n"
19021 " nlevel and\n"
19022 " clevel.\n"
19023 " opt=SURF_CONT : A contour plot is drawn at the surface plane\n"
19024 " using parameters\n"
19025 " nlevel and\n"
19026 " clevel.\n"
19027 " opt=DRAW_SIDES : draws a curtain between the base XY plane and\n"
19028 " the borders of the plotted function.\n"
19029 " opt=MAG_COLOR : the surface is colored according to the value\n"
19030 " of Z; if MAG_COLOR is not used, then the surface is colored\n"
19031 " according to the intensity of the reflected light in the\n"
19032 " surface from a light source whose position is set using\n"
19033 " pllightsource.\n"
19034 "\n"
19035 "\n"
19036 " clevel (PLFLT_VECTOR, input) : A vector containing the contour\n"
19037 " levels.\n"
19038 "\n"
19039 " nlevel (PLINT, input) : Number of elements in the clevel vector.\n"
19040 "\n"
19041 " indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n"
19042 " corresponds to the first x index where z is defined.\n"
19043 "\n"
19044 " indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n"
19045 " which corresponds (by convention) to one more than the last x\n"
19046 " index value where z is defined.\n"
19047 "\n"
19048 " indexymin (PLINT_VECTOR, input) : A vector containing the y index\n"
19049 " values which all must be ≥ 0. These values are the first y index\n"
19050 " where z is defined for a particular x index in the range from\n"
19051 " indexxmin to indexxmax - 1. The dimension of indexymin is\n"
19052 " indexxmax.\n"
19053 "\n"
19054 " indexymax (PLINT_VECTOR, input) : A vector containing the y index\n"
19055 " values which all must be ≤ ny. These values correspond (by\n"
19056 " convention) to one more than the last y index where z is defined\n"
19057 " for a particular x index in the range from indexxmin to indexxmax\n"
19058 " - 1. The dimension of indexymax is indexxmax.\n"
19059 "\n"
19060 ""},
19061 { "plparseopts", _wrap_plparseopts, METH_VARARGS, "\n"
19062 "Parse command-line arguments\n"
19063 "\n"
19064 "DESCRIPTION:\n"
19065 "\n"
19066 " Parse command-line arguments.\n"
19067 "\n"
19068 " plparseopts removes all recognized flags (decreasing argc\n"
19069 " accordingly), so that invalid input may be readily detected. It can\n"
19070 " also be used to process user command line flags. The user can merge\n"
19071 " an option table of type PLOptionTable into the internal option table\n"
19072 " info structure using plMergeOpts. Or, the user can specify that ONLY\n"
19073 " the external table(s) be parsed by calling plClearOpts before\n"
19074 " plMergeOpts.\n"
19075 "\n"
19076 " The default action taken by plparseopts is as follows:\n"
19077 " Returns with an error if an unrecognized option or badly formed\n"
19078 " option-value pair are encountered.\n"
19079 " Returns immediately (return code 0) when the first non-option command\n"
19080 " line argument is found.\n"
19081 " Returns with the return code of the option handler, if one was called.\n"
19082 "\n"
19083 " Deletes command line arguments from argv list as they are found, and\n"
19084 " decrements argc accordingly.\n"
19085 " Does not show \"invisible\" options in usage or help messages.\n"
19086 " Assumes the program name is contained in argv[0].\n"
19087 "\n"
19088 " These behaviors may be controlled through the\n"
19089 " mode argument.\n"
19090 "\n"
19091 " Redacted form: General: plparseopts(argv, mode)\n"
19092 "\n"
19093 "\n"
19094 " This function is used in all of the examples.\n"
19095 "\n"
19096 "\n"
19097 "\n"
19098 "SYNOPSIS:\n"
19099 "\n"
19100 "PLINT plparseopts(p_argc, argv, mode)\n"
19101 "\n"
19102 "ARGUMENTS:\n"
19103 "\n"
19104 " p_argc (int *, input/output) : Number of arguments.\n"
19105 "\n"
19106 " argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n"
19107 " strings containing *p_argc command-line arguments.\n"
19108 "\n"
19109 " mode (PLINT, input) : Parsing mode with the following\n"
19110 " possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n"
19111 " and all error messages enabled, including program exit when an\n"
19112 " error occurs. Anything on the command line that isn't recognized\n"
19113 " as a valid option or option argument is flagged as an error.\n"
19114 " PL_PARSE_QUIET (2) -- Turns off all output except in the case\n"
19115 " of errors.\n"
19116 " PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n"
19117 " arguments.\n"
19118 " PL_PARSE_SHOWALL (8) -- Show invisible options\n"
19119 " PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n"
19120 " pointer to the program name.\n"
19121 " PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n"
19122 " PL_PARSE_SKIP (128) -- Set to quietly skip over any\n"
19123 " unrecognized arguments.\n"
19124 "\n"
19125 ""},
19126 { "plpat", _wrap_plpat, METH_VARARGS, "\n"
19127 "Set area line fill pattern\n"
19128 "\n"
19129 "DESCRIPTION:\n"
19130 "\n"
19131 " Sets the area line fill pattern to be used, e.g., for calls to plfill.\n"
19132 " The pattern consists of 1 or 2 sets of parallel lines with specified\n"
19133 " inclinations and spacings. The arguments to this routine are the\n"
19134 " number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n"
19135 " elements) specifying the inclinations in tenths of a degree and the\n"
19136 " spacing in micrometers. (See also plpsty)\n"
19137 "\n"
19138 " Redacted form: General: plpat(inc, del)\n"
19139 "\n"
19140 "\n"
19141 " This function is used in example 15.\n"
19142 "\n"
19143 "\n"
19144 "\n"
19145 "SYNOPSIS:\n"
19146 "\n"
19147 "plpat(nlin, inc, del)\n"
19148 "\n"
19149 "ARGUMENTS:\n"
19150 "\n"
19151 " nlin (PLINT, input) : Number of sets of lines making up the\n"
19152 " pattern, either 1 or 2.\n"
19153 "\n"
19154 " inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19155 " inclination in tenths of a degree. (Should be between -900 and\n"
19156 " 900).\n"
19157 "\n"
19158 " del (PLINT_VECTOR, input) : A vector containing nlin values of the\n"
19159 " spacing in micrometers between the lines making up the pattern.\n"
19160 "\n"
19161 ""},
19162 { "plpath", _wrap_plpath, METH_VARARGS, "\n"
19163 "Draw a line between two points, accounting for coordinate transforms\n"
19164 "\n"
19165 "DESCRIPTION:\n"
19166 "\n"
19167 " Joins the point (\n"
19168 " x1,\n"
19169 " y1) to (\n"
19170 " x2,\n"
19171 " y2) . If a global coordinate transform is defined then the line is\n"
19172 " broken in to n segments to approximate the path. If no transform is\n"
19173 " defined then this simply acts like a call to pljoin.\n"
19174 "\n"
19175 " Redacted form: plpath(n,x1,y1,x2,y2)\n"
19176 "\n"
19177 " This function is used in example 22.\n"
19178 "\n"
19179 "\n"
19180 "\n"
19181 "SYNOPSIS:\n"
19182 "\n"
19183 "plpath(n, x1, y1, x2, y2)\n"
19184 "\n"
19185 "ARGUMENTS:\n"
19186 "\n"
19187 " n (PLINT, input) : number of points to use to approximate the path.\n"
19188 "\n"
19189 " x1 (PLFLT, input) : x coordinate of first point.\n"
19190 "\n"
19191 " y1 (PLFLT, input) : y coordinate of first point.\n"
19192 "\n"
19193 " x2 (PLFLT, input) : x coordinate of second point.\n"
19194 "\n"
19195 " y2 (PLFLT, input) : y coordinate of second point.\n"
19196 "\n"
19197 ""},
19198 { "plpoin", _wrap_plpoin, METH_VARARGS, "\n"
19199 "Plot a glyph at the specified points\n"
19200 "\n"
19201 "DESCRIPTION:\n"
19202 "\n"
19203 " Plot a glyph at the specified points. (This function is largely\n"
19204 " superseded by plstring which gives access to many[!] more glyphs.)\n"
19205 " code=-1 means try to just draw a point. Right now it's just a move\n"
19206 " and a draw at the same place. Not ideal, since a sufficiently\n"
19207 " intelligent output device may optimize it away, or there may be faster\n"
19208 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19209 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19210 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19211 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19212 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19213 "\n"
19214 " Redacted form: plpoin(x, y, code)\n"
19215 "\n"
19216 " This function is used in examples 1, 6, 14, and 29.\n"
19217 "\n"
19218 "\n"
19219 "\n"
19220 "SYNOPSIS:\n"
19221 "\n"
19222 "plpoin(n, x, y, code)\n"
19223 "\n"
19224 "ARGUMENTS:\n"
19225 "\n"
19226 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19227 "\n"
19228 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19229 " points.\n"
19230 "\n"
19231 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19232 " points.\n"
19233 "\n"
19234 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19235 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19236 " each of the n points.\n"
19237 "\n"
19238 ""},
19239 { "plpoin3", _wrap_plpoin3, METH_VARARGS, "\n"
19240 "Plot a glyph at the specified 3D points\n"
19241 "\n"
19242 "DESCRIPTION:\n"
19243 "\n"
19244 " Plot a glyph at the specified 3D points. (This function is largely\n"
19245 " superseded by plstring3 which gives access to many[!] more glyphs.)\n"
19246 " Set up the call to this function similar to what is done for plline3.\n"
19247 " code=-1 means try to just draw a point. Right now it's just a move\n"
19248 " and a draw at the same place. Not ideal, since a sufficiently\n"
19249 " intelligent output device may optimize it away, or there may be faster\n"
19250 " ways of doing it. This is OK for now, though, and offers a 4X speedup\n"
19251 " over drawing a Hershey font \"point\" (which is actually diamond shaped\n"
19252 " and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n"
19253 " useful (but small subset) of Hershey symbols is plotted. If 32 <=\n"
19254 " code <= 127 the corresponding printable ASCII character is plotted.\n"
19255 "\n"
19256 " Redacted form: plpoin3(x, y, z, code)\n"
19257 "\n"
19258 " This function is not used in any example.\n"
19259 "\n"
19260 "\n"
19261 "\n"
19262 "SYNOPSIS:\n"
19263 "\n"
19264 "plpoin3(n, x, y, z, code)\n"
19265 "\n"
19266 "ARGUMENTS:\n"
19267 "\n"
19268 " n (PLINT, input) : Number of points in the x and y vectors.\n"
19269 "\n"
19270 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
19271 " points.\n"
19272 "\n"
19273 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
19274 " points.\n"
19275 "\n"
19276 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
19277 " points.\n"
19278 "\n"
19279 " code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n"
19280 " with -1 <= code <= 127) corresponding to a glyph to be plotted at\n"
19281 " each of the n points.\n"
19282 "\n"
19283 ""},
19284 { "plpoly3", _wrap_plpoly3, METH_VARARGS, "\n"
19285 "Draw a polygon in 3 space\n"
19286 "\n"
19287 "DESCRIPTION:\n"
19288 "\n"
19289 " Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n"
19290 " like plline3, but differs from that function in that plpoly3 attempts\n"
19291 " to determine if the polygon is viewable depending on the order of the\n"
19292 " points within the vector and the value of ifcc. If the back of\n"
19293 " polygon is facing the viewer, then it isn't drawn. If this isn't what\n"
19294 " you want, then use plline3 instead.\n"
19295 "\n"
19296 " The points are assumed to be in a plane, and the directionality of the\n"
19297 " plane is determined from the first three points. Additional points do\n"
19298 " not have to lie on the plane defined by the first three, but if they\n"
19299 " do not, then the determination of visibility obviously can't be 100%\n"
19300 " accurate... So if you're 3 space polygons are too far from planar,\n"
19301 " consider breaking them into smaller polygons. 3 points define a plane\n"
19302 " :-).\n"
19303 "\n"
19304 " Bugs: If one of the first two segments is of zero length, or if they\n"
19305 " are co-linear, the calculation of visibility has a 50/50 chance of\n"
19306 " being correct. Avoid such situations :-). See x18c.c for an example\n"
19307 " of this problem. (Search for 20.1).\n"
19308 "\n"
19309 " Redacted form: plpoly3(x, y, z, code)\n"
19310 "\n"
19311 " This function is used in example 18.\n"
19312 "\n"
19313 "\n"
19314 "\n"
19315 "SYNOPSIS:\n"
19316 "\n"
19317 "plpoly3(n, x, y, z, draw, ifcc)\n"
19318 "\n"
19319 "ARGUMENTS:\n"
19320 "\n"
19321 " n (PLINT, input) : Number of points defining line.\n"
19322 "\n"
19323 " x (PLFLT_VECTOR, input) : A vector containing\n"
19324 " n x coordinates of points.\n"
19325 "\n"
19326 " y (PLFLT_VECTOR, input) : A vector containing\n"
19327 " n y coordinates of points.\n"
19328 "\n"
19329 " z (PLFLT_VECTOR, input) : A vector containing\n"
19330 " n z coordinates of points.\n"
19331 "\n"
19332 " draw (PLBOOL_VECTOR, input) : A vector containing\n"
19333 " n-1 Boolean values which control drawing the segments of the polygon.\n"
19334 " If draw[i] is true, then the polygon segment from index [i] to\n"
19335 " [i+1] is drawn, otherwise, not.\n"
19336 "\n"
19337 " ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n"
19338 " polygon is determined by assuming the points are laid out in a\n"
19339 " counter-clockwise order. Otherwise, the directionality of the\n"
19340 " polygon is determined by assuming the points are laid out in a\n"
19341 " clockwise order.\n"
19342 "\n"
19343 ""},
19344 { "plprec", _wrap_plprec, METH_VARARGS, "\n"
19345 "Set precision in numeric labels\n"
19346 "\n"
19347 "DESCRIPTION:\n"
19348 "\n"
19349 " Sets the number of places after the decimal point in numeric labels.\n"
19350 "\n"
19351 " Redacted form: plprec(setp, prec)\n"
19352 "\n"
19353 " This function is used in example 29.\n"
19354 "\n"
19355 "\n"
19356 "\n"
19357 "SYNOPSIS:\n"
19358 "\n"
19359 "plprec(setp, prec)\n"
19360 "\n"
19361 "ARGUMENTS:\n"
19362 "\n"
19363 " setp (PLINT, input) : If setp is equal to 0 then PLplot\n"
19364 " automatically determines the number of places to use after the\n"
19365 " decimal point in numeric labels (like those used to label axes).\n"
19366 " If setp is 1 then prec sets the number of places.\n"
19367 "\n"
19368 " prec (PLINT, input) : The number of characters to draw after the\n"
19369 " decimal point in numeric labels.\n"
19370 "\n"
19371 ""},
19372 { "plpsty", _wrap_plpsty, METH_O, "\n"
19373 "Select area fill pattern\n"
19374 "\n"
19375 "DESCRIPTION:\n"
19376 "\n"
19377 " If\n"
19378 " patt is zero or less use either a hardware solid fill if the drivers\n"
19379 " have that capability (virtually all do) or fall back to a software\n"
19380 " emulation of a solid fill using the eighth area line fill pattern. If\n"
19381 " 0 <\n"
19382 " patt <= 8, then select one of eight predefined area line fill patterns\n"
19383 " to use (see plpat if you desire other patterns).\n"
19384 "\n"
19385 " Redacted form: plpsty(patt)\n"
19386 "\n"
19387 " This function is used in examples 12, 13, 15, 16, and 25.\n"
19388 "\n"
19389 "\n"
19390 "\n"
19391 "SYNOPSIS:\n"
19392 "\n"
19393 "plpsty(patt)\n"
19394 "\n"
19395 "ARGUMENTS:\n"
19396 "\n"
19397 " patt (PLINT, input) : The desired pattern index. If\n"
19398 " patt is zero or less, then a solid fill is (normally, see qualifiers\n"
19399 " above) used. For\n"
19400 " patt in the range from 1 to 8 and assuming the driver has not supplied\n"
19401 " line fill capability itself (most deliberately do not so that line\n"
19402 " fill patterns look identical for those drivers), the patterns\n"
19403 " consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n"
19404 " 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n"
19405 " lines at -30 degrees, (7) both vertical and horizontal lines, and\n"
19406 " (8) lines at both 45 degrees and -45 degrees.\n"
19407 "\n"
19408 ""},
19409 { "plptex", _wrap_plptex, METH_VARARGS, "\n"
19410 "Write text inside the viewport\n"
19411 "\n"
19412 "DESCRIPTION:\n"
19413 "\n"
19414 " Writes text at a specified position and inclination within the\n"
19415 " viewport. Text is clipped at the viewport boundaries. The reference\n"
19416 " point of a string lies along a line passing through the string at half\n"
19417 " the height of a capital letter. The position of the reference point\n"
19418 " along this line is determined by just, the reference point is placed\n"
19419 " at world coordinates (\n"
19420 " x,\n"
19421 " y) within the viewport. The inclination of the string is specified\n"
19422 " in terms of differences of world coordinates making it easy to write\n"
19423 " text parallel to a line in a graph.\n"
19424 "\n"
19425 " Redacted form: plptex(x, y, dx, dy, just, text)\n"
19426 "\n"
19427 " This function is used in example 2-4,10,12-14,20,23,24,26.\n"
19428 "\n"
19429 "\n"
19430 "\n"
19431 "SYNOPSIS:\n"
19432 "\n"
19433 "plptex(x, y, dx, dy, just, text)\n"
19434 "\n"
19435 "ARGUMENTS:\n"
19436 "\n"
19437 " x (PLFLT, input) : x coordinate of reference point of string.\n"
19438 "\n"
19439 " y (PLFLT, input) : y coordinate of reference point of string.\n"
19440 "\n"
19441 " dx (PLFLT, input) : Together with dy, this specifies the\n"
19442 " inclination of the string. The baseline of the string is parallel\n"
19443 " to a line joining (\n"
19444 " x,\n"
19445 " y) to (\n"
19446 " x+\n"
19447 " dx,\n"
19448 " y+\n"
19449 " dy) .\n"
19450 "\n"
19451 " dy (PLFLT, input) : Together with dx, this specifies the\n"
19452 " inclination of the string.\n"
19453 "\n"
19454 " just (PLFLT, input) : Specifies the position of the string relative\n"
19455 " to its reference point. If just=0. , the reference point is at\n"
19456 " the left and if just=1. , it is at the right of the string. Other\n"
19457 " values of just give intermediate justifications.\n"
19458 "\n"
19459 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19460 " written out.\n"
19461 "\n"
19462 ""},
19463 { "plptex3", _wrap_plptex3, METH_VARARGS, "\n"
19464 "Write text inside the viewport of a 3D plot\n"
19465 "\n"
19466 "DESCRIPTION:\n"
19467 "\n"
19468 " Writes text at a specified position and inclination and with a\n"
19469 " specified shear within the viewport. Text is clipped at the viewport\n"
19470 " boundaries. The reference point of a string lies along a line passing\n"
19471 " through the string at half the height of a capital letter. The\n"
19472 " position of the reference point along this line is determined by just,\n"
19473 " and the reference point is placed at world coordinates (\n"
19474 " wx,\n"
19475 " wy,\n"
19476 " wz) within the viewport. The inclination and shear of the string is\n"
19477 " specified in terms of differences of world coordinates making it easy\n"
19478 " to write text parallel to a line in a graph.\n"
19479 "\n"
19480 " Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n"
19481 "\n"
19482 " This function is used in example 28.\n"
19483 "\n"
19484 "\n"
19485 "\n"
19486 "SYNOPSIS:\n"
19487 "\n"
19488 "plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n"
19489 "\n"
19490 "ARGUMENTS:\n"
19491 "\n"
19492 " wx (PLFLT, input) : x world coordinate of reference point of\n"
19493 " string.\n"
19494 "\n"
19495 " wy (PLFLT, input) : y world coordinate of reference point of\n"
19496 " string.\n"
19497 "\n"
19498 " wz (PLFLT, input) : z world coordinate of reference point of\n"
19499 " string.\n"
19500 "\n"
19501 " dx (PLFLT, input) : Together with dy and\n"
19502 " dz , this specifies the inclination of the string. The baseline of\n"
19503 " the string is parallel to a line joining (\n"
19504 " x,\n"
19505 " y,\n"
19506 " z) to (\n"
19507 " x+\n"
19508 " dx,\n"
19509 " y+\n"
19510 " dy,\n"
19511 " z+\n"
19512 " dz) .\n"
19513 "\n"
19514 " dy (PLFLT, input) : Together with dx and\n"
19515 " dz, this specifies the inclination of the string.\n"
19516 "\n"
19517 " dz (PLFLT, input) : Together with dx and\n"
19518 " dy, this specifies the inclination of the string.\n"
19519 "\n"
19520 " sx (PLFLT, input) : Together with sy and\n"
19521 " sz , this specifies the shear of the string. The string is sheared so\n"
19522 " that the characters are vertically parallel to a line joining (\n"
19523 " x,\n"
19524 " y,\n"
19525 " z) to (\n"
19526 " x+\n"
19527 " sx,\n"
19528 " y+\n"
19529 " sy,\n"
19530 " z+\n"
19531 " sz) . If sx =\n"
19532 " sy =\n"
19533 " sz = 0.) then the text is not sheared.\n"
19534 "\n"
19535 " sy (PLFLT, input) : Together with sx and\n"
19536 " sz, this specifies shear of the string.\n"
19537 "\n"
19538 " sz (PLFLT, input) : Together with sx and\n"
19539 " sy, this specifies shear of the string.\n"
19540 "\n"
19541 " just (PLFLT, input) : Specifies the position of the string relative\n"
19542 " to its reference point. If just=0. , the reference point is at\n"
19543 " the left and if just=1. , it is at the right of the string. Other\n"
19544 " values of just give intermediate justifications.\n"
19545 "\n"
19546 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
19547 " written out.\n"
19548 "\n"
19549 ""},
19550 { "plrandd", _wrap_plrandd, METH_NOARGS, "\n"
19551 "Random number generator returning a real random number in the range [0,1]\n"
19552 "\n"
19553 "DESCRIPTION:\n"
19554 "\n"
19555 " Random number generator returning a real random number in the range\n"
19556 " [0,1]. The generator is based on the Mersenne Twister. Most languages\n"
19557 " / compilers provide their own random number generator, and so this is\n"
19558 " provided purely for convenience and to give a consistent random number\n"
19559 " generator across all languages supported by PLplot. This is\n"
19560 " particularly useful for comparing results from the test suite of\n"
19561 " examples.\n"
19562 "\n"
19563 " Redacted form: plrandd()\n"
19564 "\n"
19565 " This function is used in examples 17 and 21.\n"
19566 "\n"
19567 "\n"
19568 "\n"
19569 "SYNOPSIS:\n"
19570 "\n"
19571 "plrandd()\n"
19572 "\n"
19573 ""},
19574 { "plreplot", _wrap_plreplot, METH_NOARGS, "\n"
19575 "Replays contents of plot buffer to current device/file\n"
19576 "\n"
19577 "DESCRIPTION:\n"
19578 "\n"
19579 " Replays contents of plot buffer to current device/file.\n"
19580 "\n"
19581 " Redacted form: plreplot()\n"
19582 "\n"
19583 " This function is used in example 1,20.\n"
19584 "\n"
19585 "\n"
19586 "\n"
19587 "SYNOPSIS:\n"
19588 "\n"
19589 "plreplot()\n"
19590 "\n"
19591 ""},
19592 { "plrgbhls", _wrap_plrgbhls, METH_VARARGS, "\n"
19593 "Convert RGB color to HLS\n"
19594 "\n"
19595 "DESCRIPTION:\n"
19596 "\n"
19597 " Convert RGB color coordinates to HLS\n"
19598 "\n"
19599 " Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19600 "\n"
19601 "\n"
19602 " This function is used in example 2.\n"
19603 "\n"
19604 "\n"
19605 "\n"
19606 "SYNOPSIS:\n"
19607 "\n"
19608 "plrgbhls(r, g, b, p_h, p_l, p_s)\n"
19609 "\n"
19610 "ARGUMENTS:\n"
19611 "\n"
19612 " r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n"
19613 "\n"
19614 " g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n"
19615 "\n"
19616 " b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n"
19617 "\n"
19618 " p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n"
19619 " degrees (0.0-360.0) on the color cylinder.\n"
19620 "\n"
19621 " p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n"
19622 " expressed as a fraction (0.0-1.0) of the axis of the color\n"
19623 " cylinder.\n"
19624 "\n"
19625 " p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n"
19626 " expressed as a fraction (0.0-1.0) of the radius of the color\n"
19627 " cylinder.\n"
19628 "\n"
19629 ""},
19630 { "plschr", _wrap_plschr, METH_VARARGS, "\n"
19631 "Set character size\n"
19632 "\n"
19633 "DESCRIPTION:\n"
19634 "\n"
19635 " This sets up the size of all subsequent characters drawn. The actual\n"
19636 " height of a character is the product of the default character size and\n"
19637 " a scaling factor.\n"
19638 "\n"
19639 " Redacted form: plschr(def, scale)\n"
19640 "\n"
19641 " This function is used in examples 2, 13, 23, and 24.\n"
19642 "\n"
19643 "\n"
19644 "\n"
19645 "SYNOPSIS:\n"
19646 "\n"
19647 "plschr(def, scale)\n"
19648 "\n"
19649 "ARGUMENTS:\n"
19650 "\n"
19651 " def (PLFLT, input) : The default height of a character in\n"
19652 " millimeters, should be set to zero if the default height is to\n"
19653 " remain unchanged. For rasterized drivers the dx and dy values\n"
19654 " specified in plspage are used to convert from mm to pixels (note\n"
19655 " the different unit systems used). This dpi aware scaling is not\n"
19656 " implemented for all drivers yet.\n"
19657 "\n"
19658 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
19659 " actual character height.\n"
19660 "\n"
19661 ""},
19662 { "plscmap0", _wrap_plscmap0, METH_VARARGS, "\n"
19663 "Set cmap0 colors by 8-bit RGB values\n"
19664 "\n"
19665 "DESCRIPTION:\n"
19666 "\n"
19667 " Set cmap0 colors using 8-bit RGB values (see the PLplot\n"
19668 " documentation). This sets the entire color map -- only as many colors\n"
19669 " as specified will be allocated.\n"
19670 "\n"
19671 " Redacted form: plscmap0(r, g, b)\n"
19672 "\n"
19673 " This function is used in examples 2 and 24.\n"
19674 "\n"
19675 "\n"
19676 "\n"
19677 "SYNOPSIS:\n"
19678 "\n"
19679 "plscmap0(r, g, b, ncol0)\n"
19680 "\n"
19681 "ARGUMENTS:\n"
19682 "\n"
19683 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19684 " integers (0-255) representing the degree of red in the color.\n"
19685 "\n"
19686 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19687 " integers (0-255) representing the degree of green in the color.\n"
19688 "\n"
19689 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19690 " integers (0-255) representing the degree of blue in the color.\n"
19691 "\n"
19692 " ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19693 "\n"
19694 ""},
19695 { "plscmap0a", _wrap_plscmap0a, METH_VARARGS, "\n"
19696 "Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n"
19697 "\n"
19698 "DESCRIPTION:\n"
19699 "\n"
19700 " Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n"
19701 " and PLFLT alpha transparency value. This sets the entire color map --\n"
19702 " only as many colors as specified will be allocated.\n"
19703 "\n"
19704 " Redacted form: plscmap0a(r, g, b, alpha)\n"
19705 "\n"
19706 " This function is used in examples 30.\n"
19707 "\n"
19708 "\n"
19709 "\n"
19710 "SYNOPSIS:\n"
19711 "\n"
19712 "plscmap0a(r, g, b, alpha, ncol0)\n"
19713 "\n"
19714 "ARGUMENTS:\n"
19715 "\n"
19716 " r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19717 " integers (0-255) representing the degree of red in the color.\n"
19718 "\n"
19719 " g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19720 " integers (0-255) representing the degree of green in the color.\n"
19721 "\n"
19722 " b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n"
19723 " integers (0-255) representing the degree of blue in the color.\n"
19724 "\n"
19725 " alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n"
19726 " representing the alpha transparency of the color.\n"
19727 "\n"
19728 " ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19729 " vectors.\n"
19730 "\n"
19731 ""},
19732 { "plscmap0n", _wrap_plscmap0n, METH_O, "\n"
19733 "Set number of colors in cmap0\n"
19734 "\n"
19735 "DESCRIPTION:\n"
19736 "\n"
19737 " Set number of colors in cmap0 (see the PLplot documentation). Allocate\n"
19738 " (or reallocate) cmap0, and fill with default values for those colors\n"
19739 " not previously allocated. The first 16 default colors are given in\n"
19740 " the plcol0 documentation. For larger indices the default color is\n"
19741 " red.\n"
19742 "\n"
19743 " The drivers are not guaranteed to support more than 16 colors.\n"
19744 "\n"
19745 " Redacted form: plscmap0n(ncol0)\n"
19746 "\n"
19747 " This function is used in examples 15, 16, and 24.\n"
19748 "\n"
19749 "\n"
19750 "\n"
19751 "SYNOPSIS:\n"
19752 "\n"
19753 "plscmap0n(ncol0)\n"
19754 "\n"
19755 "ARGUMENTS:\n"
19756 "\n"
19757 " ncol0 (PLINT, input) : Number of colors that will be allocated in\n"
19758 " the cmap0 palette. If this number is zero or less, then the value\n"
19759 " from the previous call to plscmap0n is used and if there is no\n"
19760 " previous call, then a default value is used.\n"
19761 "\n"
19762 ""},
19763 { "plscmap1", _wrap_plscmap1, METH_VARARGS, "\n"
19764 "Set opaque RGB cmap1 colors values\n"
19765 "\n"
19766 "DESCRIPTION:\n"
19767 "\n"
19768 " Set opaque cmap1 colors (see the PLplot documentation) using RGB\n"
19769 " vector values. This function also sets the number of cmap1 colors.\n"
19770 " N.B. Continuous cmap1 colors are indexed with a floating-point index\n"
19771 " in the range from 0.0-1.0 which is linearly transformed (e.g., by\n"
19772 " plcol1) to an integer index of these RGB vectors in the range from 0\n"
19773 " to\n"
19774 " ncol1-1. So in order for this continuous color model to work\n"
19775 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19776 " that these RGB vectors are continuous functions of their integer\n"
19777 " indices.\n"
19778 "\n"
19779 " Redacted form: plscmap1(r, g, b)\n"
19780 "\n"
19781 " This function is used in example 31.\n"
19782 "\n"
19783 "\n"
19784 "\n"
19785 "SYNOPSIS:\n"
19786 "\n"
19787 "plscmap1(r, g, b, ncol1)\n"
19788 "\n"
19789 "ARGUMENTS:\n"
19790 "\n"
19791 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19792 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19793 " color as a continuous function of the integer index of the vector.\n"
19794 "\n"
19795 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19796 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19797 " color as a continuous function of the integer index of the vector.\n"
19798 "\n"
19799 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19800 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19801 " color as a continuous function of the integer index of the vector.\n"
19802 "\n"
19803 " ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n"
19804 "\n"
19805 ""},
19806 { "plscmap1a", _wrap_plscmap1a, METH_VARARGS, "\n"
19807 "Set semitransparent cmap1 RGBA colors.\n"
19808 "\n"
19809 "DESCRIPTION:\n"
19810 "\n"
19811 " Set semitransparent cmap1 colors (see the PLplot documentation) using\n"
19812 " RGBA vector values. This function also sets the number of cmap1\n"
19813 " colors. N.B. Continuous cmap1 colors are indexed with a\n"
19814 " floating-point index in the range from 0.0-1.0 which is linearly\n"
19815 " transformed (e.g., by plcol1) to an integer index of these RGBA\n"
19816 " vectors in the range from 0 to\n"
19817 " ncol1-1. So in order for this continuous color model to work\n"
19818 " properly, it is the responsibility of the user of plscmap1 to insure\n"
19819 " that these RGBA vectors are continuous functions of their integer\n"
19820 " indices.\n"
19821 "\n"
19822 " Redacted form: plscmap1a(r, g, b, alpha)\n"
19823 "\n"
19824 " This function is used in example 31.\n"
19825 "\n"
19826 "\n"
19827 "\n"
19828 "SYNOPSIS:\n"
19829 "\n"
19830 "plscmap1a(r, g, b, alpha, ncol1)\n"
19831 "\n"
19832 "ARGUMENTS:\n"
19833 "\n"
19834 " r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19835 " 8-bit integers in the range from 0-255) the degree of red in the\n"
19836 " color as a continuous function of the integer index of the vector.\n"
19837 "\n"
19838 " g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19839 " 8-bit integers in the range from 0-255) the degree of green in the\n"
19840 " color as a continuous function of the integer index of the vector.\n"
19841 "\n"
19842 " b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n"
19843 " 8-bit integers in the range from 0-255) the degree of blue in the\n"
19844 " color as a continuous function of the integer index of the vector.\n"
19845 "\n"
19846 " alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n"
19847 " values in the range from 0.0-1.0 where 0.0 corresponds to\n"
19848 " completely transparent and 1.0 corresponds to completely opaque)\n"
19849 " the alpha transparency of the color as a continuous function of\n"
19850 " the integer index of the vector.\n"
19851 "\n"
19852 " ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n"
19853 " vectors.\n"
19854 "\n"
19855 ""},
19856 { "plscmap1l", _wrap_plscmap1l, METH_VARARGS, "\n"
19857 "Set cmap1 colors using a piece-wise linear relationship\n"
19858 "\n"
19859 "DESCRIPTION:\n"
19860 "\n"
19861 " Set cmap1 colors using a piece-wise linear relationship between the\n"
19862 " cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n"
19863 " (see the PLplot documentation). May be called at any time.\n"
19864 "\n"
19865 " The idea here is to specify a number of control points that define the\n"
19866 " mapping between input cmap1 intensity indices and HLS or RGB. Between\n"
19867 " these points, linear interpolation is used which gives a smooth\n"
19868 " variation of color with intensity index. Any number of control points\n"
19869 " may be specified, located at arbitrary positions, although typically 2\n"
19870 " - 4 are enough. Another way of stating this is that we are traversing\n"
19871 " a given number of lines through HLS or RGB space as we move through\n"
19872 " cmap1 intensity indices. The control points at the minimum and\n"
19873 " maximum position (0 and 1) must always be specified. By adding more\n"
19874 " control points you can get more variation. One good technique for\n"
19875 " plotting functions that vary about some expected average is to use an\n"
19876 " additional 2 control points in the center (position ~= 0.5) that are\n"
19877 " the same lightness as the background (typically white for paper\n"
19878 " output, black for crt), and same hue as the boundary control points.\n"
19879 " This allows the highs and lows to be very easily distinguished.\n"
19880 "\n"
19881 " Each control point must specify the cmap1 intensity index and the\n"
19882 " associated three coordinates in HLS or RGB space. The first point\n"
19883 " must correspond to position = 0, and the last to position = 1.\n"
19884 "\n"
19885 " If RGB colors are provided then the interpolation takes place in RGB\n"
19886 " space and is trivial. However if HLS colors are provided then, because\n"
19887 " of the circular nature of the color wheel for the hue coordinate, the\n"
19888 " interpolation could be performed in either direction around the color\n"
19889 " wheel. The default behaviour is for the hue to be linearly\n"
19890 " interpolated ignoring this circular property of hue. So for example,\n"
19891 " the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n"
19892 " green and cyan. If instead you wish to interpolate the other way\n"
19893 " around the color wheel you have two options. You may provide hues\n"
19894 " outside the range [0, 360), so by using a hue of -120 for blue or 360\n"
19895 " for red the interpolation will proceed via magenta. Alternatively you\n"
19896 " can utilise the alt_hue_path variable to reverse the direction of\n"
19897 " interpolation if you need to provide hues within the [0-360) range.\n"
19898 "\n"
19899 " Examples of interpolation Huealt_hue_pathcolor scheme[120\n"
19900 " 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n"
19901 " -120]falsegreen-yellow-red-magenta-blue[240\n"
19902 " 480]falseblue-magenta-red-yellow-green[120\n"
19903 " 240]truegreen-yellow-red-magenta-blue[240\n"
19904 " 120]trueblue-magenta-red-yellow-green\n"
19905 "\n"
19906 " Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n"
19907 " 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n"
19908 " 1]magnitudeHLSsaturation[0, 1]magnitude\n"
19909 "\n"
19910 " Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n"
19911 " alt_hue_path)\n"
19912 "\n"
19913 " This function is used in examples 8, 11, 12, 15, 20, and 21.\n"
19914 "\n"
19915 "\n"
19916 "\n"
19917 "SYNOPSIS:\n"
19918 "\n"
19919 "plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n"
19920 "\n"
19921 "ARGUMENTS:\n"
19922 "\n"
19923 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19924 "\n"
19925 " npts (PLINT, input) : number of control points\n"
19926 "\n"
19927 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19928 " intensity index (0.0-1.0) in ascending order for each control\n"
19929 " point.\n"
19930 "\n"
19931 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19932 " coordinate (H or R) for each control point.\n"
19933 "\n"
19934 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19935 " coordinate (L or G) for each control point.\n"
19936 "\n"
19937 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19938 " coordinate (S or B) for each control point.\n"
19939 "\n"
19940 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19941 " npts - 1 elements), each containing either true to use the reversed\n"
19942 " HLS interpolation or false to use the regular HLS interpolation.\n"
19943 " (alt_hue_path[i] refers to the interpolation interval between the\n"
19944 " i and i + 1 control points). This parameter is not used for RGB\n"
19945 " colors (\n"
19946 " itype = true).\n"
19947 "\n"
19948 ""},
19949 { "plscmap1la", _wrap_plscmap1la, METH_VARARGS, "\n"
19950 "Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n"
19951 "\n"
19952 "DESCRIPTION:\n"
19953 "\n"
19954 " This is a variant of plscmap1l that supports alpha channel\n"
19955 " transparency. It sets cmap1 colors using a piece-wise linear\n"
19956 " relationship between cmap1 intensity index (0.0-1.0) and position in\n"
19957 " HLS or RGB color space (see the PLplot documentation) with alpha\n"
19958 " transparency value (0.0-1.0). It may be called at any time.\n"
19959 "\n"
19960 " Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n"
19961 " alpha, alt_hue_path)\n"
19962 "\n"
19963 " This function is used in example 30.\n"
19964 "\n"
19965 "\n"
19966 "\n"
19967 "SYNOPSIS:\n"
19968 "\n"
19969 "plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n"
19970 "\n"
19971 "ARGUMENTS:\n"
19972 "\n"
19973 " itype (PLBOOL, input) : true: RGB, false: HLS.\n"
19974 "\n"
19975 " npts (PLINT, input) : number of control points.\n"
19976 "\n"
19977 " intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n"
19978 " intensity index (0.0-1.0) in ascending order for each control\n"
19979 " point.\n"
19980 "\n"
19981 " coord1 (PLFLT_VECTOR, input) : A vector containing the first\n"
19982 " coordinate (H or R) for each control point.\n"
19983 "\n"
19984 " coord2 (PLFLT_VECTOR, input) : A vector containing the second\n"
19985 " coordinate (L or G) for each control point.\n"
19986 "\n"
19987 " coord3 (PLFLT_VECTOR, input) : A vector containing the third\n"
19988 " coordinate (S or B) for each control point.\n"
19989 "\n"
19990 " alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n"
19991 " transparency value (0.0-1.0) for each control point.\n"
19992 "\n"
19993 " alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n"
19994 " npts - 1 elements) containing the alternative interpolation method\n"
19995 " Boolean value for each control point interval. (alt_hue_path[i]\n"
19996 " refers to the interpolation interval between the i and i + 1\n"
19997 " control points).\n"
19998 "\n"
19999 ""},
20000 { "plscmap1n", _wrap_plscmap1n, METH_O, "\n"
20001 "Set number of colors in cmap1\n"
20002 "\n"
20003 "DESCRIPTION:\n"
20004 "\n"
20005 " Set number of colors in cmap1, (re-)allocate cmap1, and set default\n"
20006 " values if this is the first allocation (see the PLplot documentation).\n"
20007 "\n"
20008 " Redacted form: plscmap1n(ncol1)\n"
20009 "\n"
20010 " This function is used in examples 8, 11, 20, and 21.\n"
20011 "\n"
20012 "\n"
20013 "\n"
20014 "SYNOPSIS:\n"
20015 "\n"
20016 "plscmap1n(ncol1)\n"
20017 "\n"
20018 "ARGUMENTS:\n"
20019 "\n"
20020 " ncol1 (PLINT, input) : Number of colors that will be allocated in\n"
20021 " the cmap1 palette. If this number is zero or less, then the value\n"
20022 " from the previous call to plscmap1n is used and if there is no\n"
20023 " previous call, then a default value is used.\n"
20024 "\n"
20025 ""},
20026 { "plscmap1_range", _wrap_plscmap1_range, METH_VARARGS, "\n"
20027 "Set the cmap1 argument range for continuous color plots\n"
20028 "\n"
20029 "DESCRIPTION:\n"
20030 "\n"
20031 " Set the cmap1 argument range for continuous color plots that\n"
20032 " corresponds to the range of data values. The maximum range\n"
20033 " corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n"
20034 " the cmap1 argument range that is specified with this routine, the\n"
20035 " smaller the subset of the cmap1 color palette that is used to\n"
20036 " represent the continuous data being plotted. If\n"
20037 " min_color is greater than\n"
20038 " max_color or\n"
20039 " max_color is greater than 1.0 or\n"
20040 " min_color is less than 0.0 then no change is made to the cmap1\n"
20041 " argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n"
20042 "\n"
20043 " Redacted form: plscmap1_range(min_color, max_color)\n"
20044 "\n"
20045 " This function is currently used in example 33.\n"
20046 "\n"
20047 "\n"
20048 "\n"
20049 "SYNOPSIS:\n"
20050 "\n"
20051 "plscmap1_range(min_color, max_color)\n"
20052 "\n"
20053 "ARGUMENTS:\n"
20054 "\n"
20055 " min_color (PLFLT, input) : The minimum cmap1 argument. If less\n"
20056 " than 0.0, then 0.0 is used instead.\n"
20057 "\n"
20058 " max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n"
20059 " than 1.0, then 1.0 is used instead.\n"
20060 "\n"
20061 ""},
20062 { "plgcmap1_range", _wrap_plgcmap1_range, METH_NOARGS, "\n"
20063 "Get the cmap1 argument range for continuous color plots\n"
20064 "\n"
20065 "DESCRIPTION:\n"
20066 "\n"
20067 " Get the cmap1 argument range for continuous color plots. (Use\n"
20068 " plscmap1_range to set the cmap1 argument range.)\n"
20069 "\n"
20070 " Redacted form: plgcmap1_range(min_color, max_color)\n"
20071 "\n"
20072 " This function is currently not used in any example.\n"
20073 "\n"
20074 "\n"
20075 "\n"
20076 "SYNOPSIS:\n"
20077 "\n"
20078 "plgcmap1_range(min_color, max_color)\n"
20079 "\n"
20080 "ARGUMENTS:\n"
20081 "\n"
20082 " min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20083 " minimum cmap1 argument.\n"
20084 "\n"
20085 " max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n"
20086 " maximum cmap1 argument.\n"
20087 "\n"
20088 ""},
20089 { "plscol0", _wrap_plscol0, METH_VARARGS, "\n"
20090 "Set 8-bit RGB values for given cmap0 color index\n"
20091 "\n"
20092 "DESCRIPTION:\n"
20093 "\n"
20094 " Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n"
20095 " index. Overwrites the previous color value for the given index and,\n"
20096 " thus, does not result in any additional allocation of space for\n"
20097 " colors.\n"
20098 "\n"
20099 " Redacted form: plscol0(icol0, r, g, b)\n"
20100 "\n"
20101 " This function is used in any example 31.\n"
20102 "\n"
20103 "\n"
20104 "\n"
20105 "SYNOPSIS:\n"
20106 "\n"
20107 "plscol0(icol0, r, g, b)\n"
20108 "\n"
20109 "ARGUMENTS:\n"
20110 "\n"
20111 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20112 " number of colors (which is set by default, by plscmap0n, or even\n"
20113 " by plscmap0).\n"
20114 "\n"
20115 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20116 " degree of red in the color.\n"
20117 "\n"
20118 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20119 " degree of green in the color.\n"
20120 "\n"
20121 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20122 " degree of blue in the color.\n"
20123 "\n"
20124 ""},
20125 { "plscol0a", _wrap_plscol0a, METH_VARARGS, "\n"
20126 "Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n"
20127 "\n"
20128 "DESCRIPTION:\n"
20129 "\n"
20130 " Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n"
20131 " (see the PLplot documentation) index. Overwrites the previous color\n"
20132 " value for the given index and, thus, does not result in any additional\n"
20133 " allocation of space for colors.\n"
20134 "\n"
20135 " This function is used in example 30.\n"
20136 "\n"
20137 "\n"
20138 "\n"
20139 "SYNOPSIS:\n"
20140 "\n"
20141 "plscol0a(icol0, r, g, b, alpha)\n"
20142 "\n"
20143 "ARGUMENTS:\n"
20144 "\n"
20145 " icol0 (PLINT, input) : Color index. Must be less than the maximum\n"
20146 " number of colors (which is set by default, by plscmap0n, or even\n"
20147 " by plscmap0).\n"
20148 "\n"
20149 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20150 " degree of red in the color.\n"
20151 "\n"
20152 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20153 " degree of green in the color.\n"
20154 "\n"
20155 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20156 " degree of blue in the color.\n"
20157 "\n"
20158 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20159 " (0.0-1.0).\n"
20160 "\n"
20161 ""},
20162 { "plscolbg", _wrap_plscolbg, METH_VARARGS, "\n"
20163 "Set the background color by 8-bit RGB value\n"
20164 "\n"
20165 "DESCRIPTION:\n"
20166 "\n"
20167 " Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n"
20168 " the PLplot documentation).\n"
20169 "\n"
20170 " Redacted form: plscolbg(r, g, b)\n"
20171 "\n"
20172 " This function is used in examples 15 and 31.\n"
20173 "\n"
20174 "\n"
20175 "\n"
20176 "SYNOPSIS:\n"
20177 "\n"
20178 "plscolbg(r, g, b)\n"
20179 "\n"
20180 "ARGUMENTS:\n"
20181 "\n"
20182 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20183 " degree of red in the color.\n"
20184 "\n"
20185 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20186 " degree of green in the color.\n"
20187 "\n"
20188 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20189 " degree of blue in the color.\n"
20190 "\n"
20191 ""},
20192 { "plscolbga", _wrap_plscolbga, METH_VARARGS, "\n"
20193 "Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n"
20194 "\n"
20195 "DESCRIPTION:\n"
20196 "\n"
20197 " Set the background color (color 0 in cmap0) by 8-bit RGB value and\n"
20198 " PLFLT alpha transparency value (see the PLplot documentation).\n"
20199 "\n"
20200 " This function is used in example 31.\n"
20201 "\n"
20202 "\n"
20203 "\n"
20204 "SYNOPSIS:\n"
20205 "\n"
20206 "plscolbga(r, g, b, alpha)\n"
20207 "\n"
20208 "ARGUMENTS:\n"
20209 "\n"
20210 " r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20211 " degree of red in the color.\n"
20212 "\n"
20213 " g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20214 " degree of green in the color.\n"
20215 "\n"
20216 " b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n"
20217 " degree of blue in the color.\n"
20218 "\n"
20219 " alpha (PLFLT, input) : Value of the alpha transparency in the range\n"
20220 " (0.0-1.0).\n"
20221 "\n"
20222 ""},
20223 { "plscolor", _wrap_plscolor, METH_O, "\n"
20224 "Used to globally turn color output on/off\n"
20225 "\n"
20226 "DESCRIPTION:\n"
20227 "\n"
20228 " Used to globally turn color output on/off for those drivers/devices\n"
20229 " that support it.\n"
20230 "\n"
20231 " Redacted form: plscolor(color)\n"
20232 "\n"
20233 " This function is used in example 31.\n"
20234 "\n"
20235 "\n"
20236 "\n"
20237 "SYNOPSIS:\n"
20238 "\n"
20239 "plscolor(color)\n"
20240 "\n"
20241 "ARGUMENTS:\n"
20242 "\n"
20243 " color (PLINT, input) : Color flag (Boolean). If zero, color is\n"
20244 " turned off. If non-zero, color is turned on.\n"
20245 "\n"
20246 ""},
20247 { "plscompression", _wrap_plscompression, METH_O, "\n"
20248 "Set device-compression level\n"
20249 "\n"
20250 "DESCRIPTION:\n"
20251 "\n"
20252 " Set device-compression level. Only used for drivers that provide\n"
20253 " compression. This function, if used, should be invoked before a call\n"
20254 " to plinit.\n"
20255 "\n"
20256 " Redacted form: plscompression(compression)\n"
20257 "\n"
20258 " This function is used in example 31.\n"
20259 "\n"
20260 "\n"
20261 "\n"
20262 "SYNOPSIS:\n"
20263 "\n"
20264 "plscompression(compression)\n"
20265 "\n"
20266 "ARGUMENTS:\n"
20267 "\n"
20268 " compression (PLINT, input) : The desired compression level. This is\n"
20269 " a device-dependent value. Currently only the jpeg and png devices\n"
20270 " use these values. For jpeg value is the jpeg quality which should\n"
20271 " normally be in the range 0-95. Higher values denote higher quality\n"
20272 " and hence larger image sizes. For png values are in the range -1\n"
20273 " to 99. Values of 0-9 are taken as the compression level for zlib.\n"
20274 " A value of -1 denotes the default zlib compression level. Values\n"
20275 " in the range 10-99 are divided by 10 and then used as the zlib\n"
20276 " compression level. Higher compression levels correspond to greater\n"
20277 " compression and small file sizes at the expense of more\n"
20278 " computation.\n"
20279 "\n"
20280 ""},
20281 { "plsdev", _wrap_plsdev, METH_O, "\n"
20282 "Set the device (keyword) name\n"
20283 "\n"
20284 "DESCRIPTION:\n"
20285 "\n"
20286 " Set the device (keyword) name.\n"
20287 "\n"
20288 " Redacted form: plsdev(devname)\n"
20289 "\n"
20290 " This function is used in examples 1, 14, and 20.\n"
20291 "\n"
20292 "\n"
20293 "\n"
20294 "SYNOPSIS:\n"
20295 "\n"
20296 "plsdev(devname)\n"
20297 "\n"
20298 "ARGUMENTS:\n"
20299 "\n"
20300 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
20301 " containing the device name keyword of the required output device.\n"
20302 " If\n"
20303 " devname is NULL or if the first character of the string is a ``?'',\n"
20304 " the normal (prompted) start up is used.\n"
20305 "\n"
20306 ""},
20307 { "plsdidev", _wrap_plsdidev, METH_VARARGS, "\n"
20308 "Set parameters that define current device-space window\n"
20309 "\n"
20310 "DESCRIPTION:\n"
20311 "\n"
20312 " Set relative margin width, aspect ratio, and relative justification\n"
20313 " that define current device-space window. If you want to just use the\n"
20314 " previous value for any of these, just pass in the magic value\n"
20315 " PL_NOTSET. It is unlikely that one should ever need to change the\n"
20316 " aspect ratio but it's in there for completeness. If plsdidev is not\n"
20317 " called the default values of mar, jx, and jy are all 0. aspect is set\n"
20318 " to a device-specific value.\n"
20319 "\n"
20320 " Redacted form: plsdidev(mar, aspect, jx, jy)\n"
20321 "\n"
20322 " This function is used in example 31.\n"
20323 "\n"
20324 "\n"
20325 "\n"
20326 "SYNOPSIS:\n"
20327 "\n"
20328 "plsdidev(mar, aspect, jx, jy)\n"
20329 "\n"
20330 "ARGUMENTS:\n"
20331 "\n"
20332 " mar (PLFLT, input) : Relative margin width.\n"
20333 "\n"
20334 " aspect (PLFLT, input) : Aspect ratio.\n"
20335 "\n"
20336 " jx (PLFLT, input) : Relative justification in x. Value must lie in\n"
20337 " the range -0.5 to 0.5.\n"
20338 "\n"
20339 " jy (PLFLT, input) : Relative justification in y. Value must lie in\n"
20340 " the range -0.5 to 0.5.\n"
20341 "\n"
20342 ""},
20343 { "plsdimap", _wrap_plsdimap, METH_VARARGS, "\n"
20344 "Set up transformation from metafile coordinates\n"
20345 "\n"
20346 "DESCRIPTION:\n"
20347 "\n"
20348 " Set up transformation from metafile coordinates. The size of the plot\n"
20349 " is scaled so as to preserve aspect ratio. This isn't intended to be a\n"
20350 " general-purpose facility just yet (not sure why the user would need\n"
20351 " it, for one).\n"
20352 "\n"
20353 " Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n"
20354 " dimypmm)\n"
20355 "\n"
20356 " This function is not used in any examples.\n"
20357 "\n"
20358 "\n"
20359 "\n"
20360 "SYNOPSIS:\n"
20361 "\n"
20362 "plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n"
20363 "\n"
20364 "ARGUMENTS:\n"
20365 "\n"
20366 " dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n"
20367 "\n"
20368 " dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n"
20369 "\n"
20370 " dimymin (PLINT, input) : NEEDS DOCUMENTATION\n"
20371 "\n"
20372 " dimymax (PLINT, input) : NEEDS DOCUMENTATION\n"
20373 "\n"
20374 " dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20375 "\n"
20376 " dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n"
20377 "\n"
20378 ""},
20379 { "plsdiori", _wrap_plsdiori, METH_O, "\n"
20380 "Set plot orientation\n"
20381 "\n"
20382 "DESCRIPTION:\n"
20383 "\n"
20384 " Set plot orientation parameter which is multiplied by 90 degrees to\n"
20385 " obtain the angle of rotation. Note, arbitrary rotation parameters\n"
20386 " such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n"
20387 " values for the rotation parameter are 0., 1., 2., and 3. corresponding\n"
20388 " to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n"
20389 " (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n"
20390 " not called the default value of rot is 0.\n"
20391 "\n"
20392 " N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n"
20393 " probably want to change the aspect ratio to a value suitable for the\n"
20394 " plot orientation using a call to plsdidev or the command-line options\n"
20395 " -a or -freeaspect. For more documentation of those options see the\n"
20396 " PLplot documentation. Such command-line options can be set internally\n"
20397 " using plsetopt or set directly using the command line and parsed using\n"
20398 " a call to plparseopts.\n"
20399 "\n"
20400 " Redacted form: plsdiori(rot)\n"
20401 "\n"
20402 " This function is not used in any examples.\n"
20403 "\n"
20404 "\n"
20405 "\n"
20406 "SYNOPSIS:\n"
20407 "\n"
20408 "plsdiori(rot)\n"
20409 "\n"
20410 "ARGUMENTS:\n"
20411 "\n"
20412 " rot (PLFLT, input) : Plot orientation parameter.\n"
20413 "\n"
20414 ""},
20415 { "plsdiplt", _wrap_plsdiplt, METH_VARARGS, "\n"
20416 "Set parameters that define current plot-space window\n"
20417 "\n"
20418 "DESCRIPTION:\n"
20419 "\n"
20420 " Set relative minima and maxima that define the current plot-space\n"
20421 " window. If plsdiplt is not called the default values of xmin, ymin,\n"
20422 " xmax, and ymax are 0., 0., 1., and 1.\n"
20423 "\n"
20424 " Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n"
20425 "\n"
20426 " This function is used in example 31.\n"
20427 "\n"
20428 "\n"
20429 "\n"
20430 "SYNOPSIS:\n"
20431 "\n"
20432 "plsdiplt(xmin, ymin, xmax, ymax)\n"
20433 "\n"
20434 "ARGUMENTS:\n"
20435 "\n"
20436 " xmin (PLFLT, input) : Relative minimum in x.\n"
20437 "\n"
20438 " ymin (PLFLT, input) : Relative minimum in y.\n"
20439 "\n"
20440 " xmax (PLFLT, input) : Relative maximum in x.\n"
20441 "\n"
20442 " ymax (PLFLT, input) : Relative maximum in y.\n"
20443 "\n"
20444 ""},
20445 { "plsdiplz", _wrap_plsdiplz, METH_VARARGS, "\n"
20446 "Set parameters incrementally (zoom mode) that define current plot-space window\n"
20447 "\n"
20448 "DESCRIPTION:\n"
20449 "\n"
20450 " Set relative minima and maxima incrementally (zoom mode) that define\n"
20451 " the current plot-space window. This function has the same effect as\n"
20452 " plsdiplt if that function has not been previously called. Otherwise,\n"
20453 " this function implements zoom mode using the transformation min_used =\n"
20454 " old_min + old_length*min and max_used = old_min + old_length*max for\n"
20455 " each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n"
20456 " repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n"
20457 "\n"
20458 " Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n"
20459 "\n"
20460 " This function is used in example 31.\n"
20461 "\n"
20462 "\n"
20463 "\n"
20464 "SYNOPSIS:\n"
20465 "\n"
20466 "plsdiplz(xmin, ymin, xmax, ymax)\n"
20467 "\n"
20468 "ARGUMENTS:\n"
20469 "\n"
20470 " xmin (PLFLT, input) : Relative (incremental) minimum in x.\n"
20471 "\n"
20472 " ymin (PLFLT, input) : Relative (incremental) minimum in y.\n"
20473 "\n"
20474 " xmax (PLFLT, input) : Relative (incremental) maximum in x.\n"
20475 "\n"
20476 " ymax (PLFLT, input) : Relative (incremental) maximum in y.\n"
20477 "\n"
20478 ""},
20479 { "plseed", _wrap_plseed, METH_O, "\n"
20480 "Set seed for internal random number generator.\n"
20481 "\n"
20482 "DESCRIPTION:\n"
20483 "\n"
20484 " Set the seed for the internal random number generator. See plrandd for\n"
20485 " further details.\n"
20486 "\n"
20487 " Redacted form: plseed(seed)\n"
20488 "\n"
20489 " This function is used in example 21.\n"
20490 "\n"
20491 "\n"
20492 "\n"
20493 "SYNOPSIS:\n"
20494 "\n"
20495 "plseed(seed)\n"
20496 "\n"
20497 "ARGUMENTS:\n"
20498 "\n"
20499 " seed (unsigned int, input) : Seed for random number generator.\n"
20500 "\n"
20501 ""},
20502 { "plsesc", _wrap_plsesc, METH_O, "\n"
20503 "Set the escape character for text strings\n"
20504 "\n"
20505 "DESCRIPTION:\n"
20506 "\n"
20507 " Set the escape character for text strings. From C (in contrast to\n"
20508 " Fortran, see plsescfortran) you pass esc as a character. Only selected\n"
20509 " characters are allowed to prevent the user from shooting himself in\n"
20510 " the foot (For example, a \\ isn't allowed since it conflicts with C's\n"
20511 " use of backslash as a character escape). Here are the allowed escape\n"
20512 " characters and their corresponding decimal ASCII values: !, ASCII 33\n"
20513 " #, ASCII 35\n"
20514 " $, ASCII 36\n"
20515 " %, ASCII 37\n"
20516 " &, ASCII 38\n"
20517 " *, ASCII 42\n"
20518 " @, ASCII 64\n"
20519 " ^, ASCII 94\n"
20520 " ~, ASCII 126\n"
20521 "\n"
20522 "\n"
20523 " Redacted form: General: plsesc(esc)\n"
20524 "\n"
20525 "\n"
20526 " This function is used in example 29.\n"
20527 "\n"
20528 "\n"
20529 "\n"
20530 "SYNOPSIS:\n"
20531 "\n"
20532 "plsesc(esc)\n"
20533 "\n"
20534 "ARGUMENTS:\n"
20535 "\n"
20536 " esc (char, input) : Escape character.\n"
20537 "\n"
20538 ""},
20539 { "plsetopt", _wrap_plsetopt, METH_VARARGS, "\n"
20540 "Set any command-line option\n"
20541 "\n"
20542 "DESCRIPTION:\n"
20543 "\n"
20544 " Set any command-line option internally from a program before it\n"
20545 " invokes plinit. opt is the name of the command-line option and optarg\n"
20546 " is the corresponding command-line option argument.\n"
20547 "\n"
20548 " This function returns 0 on success.\n"
20549 "\n"
20550 " Redacted form: plsetopt(opt, optarg)\n"
20551 "\n"
20552 " This function is used in example 14.\n"
20553 "\n"
20554 "\n"
20555 "\n"
20556 "SYNOPSIS:\n"
20557 "\n"
20558 "PLINT plsetopt(opt, optarg)\n"
20559 "\n"
20560 "ARGUMENTS:\n"
20561 "\n"
20562 " opt (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20563 " the command-line option.\n"
20564 "\n"
20565 " optarg (PLCHAR_VECTOR, input) : An ascii character string\n"
20566 " containing the argument of the command-line option.\n"
20567 "\n"
20568 ""},
20569 { "plsfam", _wrap_plsfam, METH_VARARGS, "\n"
20570 "Set family file parameters\n"
20571 "\n"
20572 "DESCRIPTION:\n"
20573 "\n"
20574 " Sets variables dealing with output file familying. Does nothing if\n"
20575 " familying not supported by the driver. This routine, if used, must be\n"
20576 " called before initializing PLplot. See the PLplot documentation for\n"
20577 " more information.\n"
20578 "\n"
20579 " Redacted form: plsfam(fam, num, bmax)\n"
20580 "\n"
20581 " This function is used in examples 14 and 31.\n"
20582 "\n"
20583 "\n"
20584 "\n"
20585 "SYNOPSIS:\n"
20586 "\n"
20587 "plsfam(fam, num, bmax)\n"
20588 "\n"
20589 "ARGUMENTS:\n"
20590 "\n"
20591 " fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n"
20592 " is enabled.\n"
20593 "\n"
20594 " num (PLINT, input) : Current family file number.\n"
20595 "\n"
20596 " bmax (PLINT, input) : Maximum file size (in bytes) for a family\n"
20597 " file.\n"
20598 "\n"
20599 ""},
20600 { "plsfci", _wrap_plsfci, METH_O, "\n"
20601 "Set FCI (font characterization integer)\n"
20602 "\n"
20603 "DESCRIPTION:\n"
20604 "\n"
20605 " Sets font characteristics to be used at the start of the next string\n"
20606 " using the FCI approach. See the PLplot documentation for more\n"
20607 " information. Note, plsfont (which calls plsfci internally) provides a\n"
20608 " more user-friendly API for setting the font characterisitics.\n"
20609 "\n"
20610 " Redacted form: General: plsfci(fci)\n"
20611 "\n"
20612 "\n"
20613 " This function is used in example 23.\n"
20614 "\n"
20615 "\n"
20616 "\n"
20617 "SYNOPSIS:\n"
20618 "\n"
20619 "plsfci(fci)\n"
20620 "\n"
20621 "ARGUMENTS:\n"
20622 "\n"
20623 " fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n"
20624 " of FCI.\n"
20625 "\n"
20626 ""},
20627 { "plsfnam", _wrap_plsfnam, METH_O, "\n"
20628 "Set output file name\n"
20629 "\n"
20630 "DESCRIPTION:\n"
20631 "\n"
20632 " Sets the current output file name, if applicable. If the file name\n"
20633 " has not been specified and is required by the driver, the user will be\n"
20634 " prompted for it. If using the X-windows output driver, this sets the\n"
20635 " display name. This routine, if used, must be called before\n"
20636 " initializing PLplot.\n"
20637 "\n"
20638 " Redacted form: plsfnam(fnam)\n"
20639 "\n"
20640 " This function is used in examples 1 and 20.\n"
20641 "\n"
20642 "\n"
20643 "\n"
20644 "SYNOPSIS:\n"
20645 "\n"
20646 "plsfnam(fnam)\n"
20647 "\n"
20648 "ARGUMENTS:\n"
20649 "\n"
20650 " fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n"
20651 " the file name.\n"
20652 "\n"
20653 ""},
20654 { "plsfont", _wrap_plsfont, METH_VARARGS, "\n"
20655 "Set family, style and weight of the current font\n"
20656 "\n"
20657 "DESCRIPTION:\n"
20658 "\n"
20659 " Sets the current font. See the PLplot documentation for more\n"
20660 " information on font selection.\n"
20661 "\n"
20662 " Redacted form: plsfont(family, style, weight)\n"
20663 "\n"
20664 " This function is used in example 23.\n"
20665 "\n"
20666 "\n"
20667 "\n"
20668 "SYNOPSIS:\n"
20669 "\n"
20670 "plsfont(family, style, weight)\n"
20671 "\n"
20672 "ARGUMENTS:\n"
20673 "\n"
20674 " family (PLINT, input) : Font family to select for the current font.\n"
20675 " The available values are given by the PL_FCI_* constants in\n"
20676 " plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n"
20677 " PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n"
20678 " signifies that the font family should not be altered.\n"
20679 "\n"
20680 " style (PLINT, input) : Font style to select for the current font.\n"
20681 " The available values are given by the PL_FCI_* constants in\n"
20682 " plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n"
20683 " PL_FCI_OBLIQUE. A negative value signifies that the font style\n"
20684 " should not be altered.\n"
20685 "\n"
20686 " weight (PLINT, input) : Font weight to select for the current font.\n"
20687 " The available values are given by the PL_FCI_* constants in\n"
20688 " plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n"
20689 " negative value signifies that the font weight should not be\n"
20690 " altered.\n"
20691 "\n"
20692 ""},
20693 { "plshades", _wrap_plshades, METH_VARARGS, "\n"
20694 "Shade regions on the basis of value\n"
20695 "\n"
20696 "DESCRIPTION:\n"
20697 "\n"
20698 " Shade regions on the basis of value. This is the high-level routine\n"
20699 " for making continuous color shaded plots with cmap1 while plshade\n"
20700 " should be used to plot individual shaded regions using either cmap0 or\n"
20701 " cmap1. examples/;<language>/x16* shows how to use plshades for each of\n"
20702 " our supported languages.\n"
20703 "\n"
20704 " Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n"
20705 " clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n"
20706 " pltr_data)\n"
20707 "\n"
20708 "\n"
20709 " This function is used in examples 16, 21, and 22.\n"
20710 "\n"
20711 "\n"
20712 "\n"
20713 "SYNOPSIS:\n"
20714 "\n"
20715 "plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n"
20716 "\n"
20717 "ARGUMENTS:\n"
20718 "\n"
20719 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20720 " plot. Should have dimensions of\n"
20721 " nx by\n"
20722 " ny.\n"
20723 "\n"
20724 " nx (PLINT, input) : First dimension of matrix \"a\".\n"
20725 "\n"
20726 " ny (PLINT, input) : Second dimension of matrix \"a\".\n"
20727 "\n"
20728 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20729 " the region that should be plotted in the shade plot. This\n"
20730 " function accepts x and y coordinates as input arguments and must\n"
20731 " return 1 if the point is to be included in the shade plot and 0\n"
20732 " otherwise. If you want to plot the entire shade plot (the usual\n"
20733 " case), this argument should be set to NULL.\n"
20734 "\n"
20735 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20736 " pltr below for how these arguments are used (only for the special case\n"
20737 " when the callback function\n"
20738 " pltr is not supplied).\n"
20739 "\n"
20740 " clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n"
20741 " corresponding to the edges of each shaded region that will be\n"
20742 " plotted by this function. To work properly the levels should be\n"
20743 " monotonic.\n"
20744 "\n"
20745 " nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n"
20746 " of shade edge values in clevel).\n"
20747 "\n"
20748 " fill_width (PLFLT, input) : Defines the line width used by the fill\n"
20749 " pattern.\n"
20750 "\n"
20751 " cont_color (PLINT, input) : Defines cmap0 pen color used for\n"
20752 " contours defining edges of shaded regions. The pen color is only\n"
20753 " temporary set for the contour drawing. Set this value to zero or\n"
20754 " less if no shade edge contours are wanted.\n"
20755 "\n"
20756 " cont_width (PLFLT, input) : Defines line width used for contours\n"
20757 " defining edges of shaded regions. This value may not be honored\n"
20758 " by all drivers. The pen width is only temporary set for the\n"
20759 " contour drawing. Set this value to zero or less if no shade edge\n"
20760 " contours are wanted.\n"
20761 "\n"
20762 " fill (PLFILL_callback, input) : Callback routine used to fill the\n"
20763 " region. Use plfill for this purpose.\n"
20764 "\n"
20765 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20766 " map to rectangles after coordinate transformation with pltrl.\n"
20767 " Otherwise, set rectangular to false. If rectangular is set to\n"
20768 " true, plshade tries to save time by filling large rectangles.\n"
20769 " This optimization fails if the coordinate transformation distorts\n"
20770 " the shape of rectangles. For example a plot in polar coordinates\n"
20771 " has to have rectangular set to false.\n"
20772 "\n"
20773 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20774 " defines the transformation between the zero-based indices of the\n"
20775 " matrix a and world coordinates. If\n"
20776 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20777 " indices of a are mapped to the range\n"
20778 " xmin through\n"
20779 " xmax and the y indices of a are mapped to the range\n"
20780 " ymin through\n"
20781 " ymax.For the C case, transformation functions are provided in the\n"
20782 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20783 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20784 " matrices. In addition, C callback routines for the transformation\n"
20785 " can be supplied by the user such as the mypltr function in\n"
20786 " examples/c/x09c.c which provides a general linear transformation\n"
20787 " between index coordinates and world coordinates.For languages\n"
20788 " other than C you should consult the PLplot documentation for the\n"
20789 " details concerning how PLTRANSFORM_callback arguments are\n"
20790 " interfaced. However, in general, a particular pattern of\n"
20791 " callback-associated arguments such as a tr vector with 6 elements;\n"
20792 " xg and yg vectors; or xg and yg matrices are respectively\n"
20793 " interfaced to a linear-transformation routine similar to the above\n"
20794 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20795 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20796 " support native language callbacks for handling index to\n"
20797 " world-coordinate transformations. Examples of these various\n"
20798 " approaches are given in examples/<language>x09*,\n"
20799 " examples/<language>x16*, examples/<language>x20*,\n"
20800 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20801 " supported languages.\n"
20802 "\n"
20803 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20804 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20805 " externally supplied.\n"
20806 "\n"
20807 ""},
20808 { "plshade", _wrap_plshade, METH_VARARGS, "\n"
20809 "Shade individual region on the basis of value\n"
20810 "\n"
20811 "DESCRIPTION:\n"
20812 "\n"
20813 " Shade individual region on the basis of value. Use plshades if you\n"
20814 " want to shade a number of contiguous regions using continuous colors.\n"
20815 " In particular the edge contours are treated properly in plshades. If\n"
20816 " you attempt to do contiguous regions with plshade the contours at the\n"
20817 " edge of the shade are partially obliterated by subsequent plots of\n"
20818 " contiguous shaded regions.\n"
20819 "\n"
20820 " Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n"
20821 " shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n"
20822 " min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n"
20823 "\n"
20824 "\n"
20825 " This function is used in example 15.\n"
20826 "\n"
20827 "\n"
20828 "\n"
20829 "SYNOPSIS:\n"
20830 "\n"
20831 "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"
20832 "\n"
20833 "ARGUMENTS:\n"
20834 "\n"
20835 " a (PLFLT_MATRIX, input) : A matrix containing function values to\n"
20836 " plot. Should have dimensions of\n"
20837 " nx by\n"
20838 " ny.\n"
20839 "\n"
20840 " nx (PLINT, input) : First dimension of the matrix \"a\".\n"
20841 "\n"
20842 " ny (PLINT, input) : Second dimension of the matrix \"a\".\n"
20843 "\n"
20844 " defined (PLDEFINED_callback, input) : Callback function specifying\n"
20845 " the region that should be plotted in the shade plot. This\n"
20846 " function accepts x and y coordinates as input arguments and must\n"
20847 " return 1 if the point is to be included in the shade plot and 0\n"
20848 " otherwise. If you want to plot the entire shade plot (the usual\n"
20849 " case), this argument should be set to NULL.\n"
20850 "\n"
20851 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
20852 " pltr below for how these arguments are used (only for the special case\n"
20853 " when the callback function\n"
20854 " pltr is not supplied).\n"
20855 "\n"
20856 " shade_min (PLFLT, input) : Defines the lower end of the interval to\n"
20857 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20858 "\n"
20859 " shade_max (PLFLT, input) : Defines the upper end of the interval to\n"
20860 " be shaded. If shade_max <= shade_min, plshade does nothing.\n"
20861 "\n"
20862 " sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n"
20863 " sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n"
20864 " then sh_color is interpreted as a cmap1 argument in the range\n"
20865 " (0.0-1.0).\n"
20866 "\n"
20867 " sh_color (PLFLT, input) : Defines color map index with integer\n"
20868 " value if cmap0 or value in range (0.0-1.0) if cmap1.\n"
20869 "\n"
20870 " sh_width (PLFLT, input) : Defines width used by the fill pattern.\n"
20871 "\n"
20872 " min_color (PLINT, input) : Defines pen color, width used by the\n"
20873 " boundary of shaded region. The min values are used for the\n"
20874 " shade_min boundary, and the max values are used on the shade_max\n"
20875 " boundary. Set color and width to zero for no plotted boundaries.\n"
20876 "\n"
20877 " min_width (PLFLT, input) : Defines pen color, width used by the\n"
20878 " boundary of shaded region. The min values are used for the\n"
20879 " shade_min boundary, and the max values are used on the shade_max\n"
20880 " boundary. Set color and width to zero for no plotted boundaries.\n"
20881 "\n"
20882 " max_color (PLINT, input) : Defines pen color, width used by the\n"
20883 " boundary of shaded region. The min values are used for the\n"
20884 " shade_min boundary, and the max values are used on the shade_max\n"
20885 " boundary. Set color and width to zero for no plotted boundaries.\n"
20886 "\n"
20887 " max_width (PLFLT, input) : Defines pen color, width used by the\n"
20888 " boundary of shaded region. The min values are used for the\n"
20889 " shade_min boundary, and the max values are used on the shade_max\n"
20890 " boundary. Set color and width to zero for no plotted boundaries.\n"
20891 "\n"
20892 " fill (PLFILL_callback, input) : Routine used to fill the region.\n"
20893 " Use plfill. Future version of PLplot may have other fill\n"
20894 " routines.\n"
20895 "\n"
20896 " rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n"
20897 " map to rectangles after coordinate transformation with pltrl.\n"
20898 " Otherwise, set rectangular to false. If rectangular is set to\n"
20899 " true, plshade tries to save time by filling large rectangles.\n"
20900 " This optimization fails if the coordinate transformation distorts\n"
20901 " the shape of rectangles. For example a plot in polar coordinates\n"
20902 " has to have rectangular set to false.\n"
20903 "\n"
20904 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
20905 " defines the transformation between the zero-based indices of the\n"
20906 " matrix a and world coordinates. If\n"
20907 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
20908 " indices of a are mapped to the range\n"
20909 " xmin through\n"
20910 " xmax and the y indices of a are mapped to the range\n"
20911 " ymin through\n"
20912 " ymax.For the C case, transformation functions are provided in the\n"
20913 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
20914 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
20915 " matrices. In addition, C callback routines for the transformation\n"
20916 " can be supplied by the user such as the mypltr function in\n"
20917 " examples/c/x09c.c which provides a general linear transformation\n"
20918 " between index coordinates and world coordinates.For languages\n"
20919 " other than C you should consult the PLplot documentation for the\n"
20920 " details concerning how PLTRANSFORM_callback arguments are\n"
20921 " interfaced. However, in general, a particular pattern of\n"
20922 " callback-associated arguments such as a tr vector with 6 elements;\n"
20923 " xg and yg vectors; or xg and yg matrices are respectively\n"
20924 " interfaced to a linear-transformation routine similar to the above\n"
20925 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
20926 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
20927 " support native language callbacks for handling index to\n"
20928 " world-coordinate transformations. Examples of these various\n"
20929 " approaches are given in examples/<language>x09*,\n"
20930 " examples/<language>x16*, examples/<language>x20*,\n"
20931 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
20932 " supported languages.\n"
20933 "\n"
20934 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
20935 " information to pltr0, pltr1, pltr2, or whatever routine that is\n"
20936 " externally supplied.\n"
20937 "\n"
20938 ""},
20939 { "plslabelfunc", _wrap_plslabelfunc, METH_VARARGS, "\n"
20940 "Assign a function to use for generating custom axis labels\n"
20941 "\n"
20942 "DESCRIPTION:\n"
20943 "\n"
20944 " This function allows a user to provide their own function to provide\n"
20945 " axis label text. The user function is given the numeric value for a\n"
20946 " point on an axis and returns a string label to correspond with that\n"
20947 " value. Custom axis labels can be enabled by passing appropriate\n"
20948 " arguments to plenv, plbox, plbox3 and similar functions.\n"
20949 "\n"
20950 " This function is used in example 19.\n"
20951 "\n"
20952 "\n"
20953 "\n"
20954 "SYNOPSIS:\n"
20955 "\n"
20956 "plslabelfunc(label_func, label_data)\n"
20957 "\n"
20958 "ARGUMENTS:\n"
20959 "\n"
20960 " label_func (PLLABEL_FUNC_callback, input) : This is the custom\n"
20961 " label function. In order to reset to the default labelling, set\n"
20962 " this to NULL. The labelling function parameters are, in order:\n"
20963 " axis: This indicates which axis a label is being requested for.\n"
20964 " The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n"
20965 "\n"
20966 " value: This is the value along the axis which is being labelled.\n"
20967 "\n"
20968 " label_text: The string representation of the label value.\n"
20969 "\n"
20970 " length: The maximum length in characters allowed for label_text.\n"
20971 "\n"
20972 "\n"
20973 " label_data (PLPointer, input) : This parameter may be used to pass\n"
20974 " data to the label_func function.\n"
20975 "\n"
20976 ""},
20977 { "plsmaj", _wrap_plsmaj, METH_VARARGS, "\n"
20978 "Set length of major ticks\n"
20979 "\n"
20980 "DESCRIPTION:\n"
20981 "\n"
20982 " This sets up the length of the major ticks. The actual length is the\n"
20983 " product of the default length and a scaling factor as for character\n"
20984 " height.\n"
20985 "\n"
20986 " Redacted form: plsmaj(def, scale)\n"
20987 "\n"
20988 " This function is used in example 29.\n"
20989 "\n"
20990 "\n"
20991 "\n"
20992 "SYNOPSIS:\n"
20993 "\n"
20994 "plsmaj(def, scale)\n"
20995 "\n"
20996 "ARGUMENTS:\n"
20997 "\n"
20998 " def (PLFLT, input) : The default length of a major tick in\n"
20999 " millimeters, should be set to zero if the default length is to\n"
21000 " remain unchanged.\n"
21001 "\n"
21002 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21003 " actual tick length.\n"
21004 "\n"
21005 ""},
21006 { "plsmem", _wrap_plsmem, METH_VARARGS, "\n"
21007 "Set the memory area to be plotted (RGB)\n"
21008 "\n"
21009 "DESCRIPTION:\n"
21010 "\n"
21011 " Set the memory area to be plotted (with the mem or memcairo driver) as\n"
21012 " the dev member of the stream structure. Also set the number of pixels\n"
21013 " in the memory passed in\n"
21014 " plotmem, which is a block of memory\n"
21015 " maxy by\n"
21016 " maxx by 3 bytes long, say: 480 x 640 x 3 (Y, X, RGB)\n"
21017 "\n"
21018 " This memory will have to be freed by the user!\n"
21019 "\n"
21020 " Redacted form: plsmem(maxx, maxy, plotmem)\n"
21021 "\n"
21022 " This function is not used in any examples.\n"
21023 "\n"
21024 "\n"
21025 "\n"
21026 "SYNOPSIS:\n"
21027 "\n"
21028 "plsmem(maxx, maxy, plotmem)\n"
21029 "\n"
21030 "ARGUMENTS:\n"
21031 "\n"
21032 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21033 "\n"
21034 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21035 "\n"
21036 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21037 " user-supplied writeable memory area.\n"
21038 "\n"
21039 ""},
21040 { "plsmema", _wrap_plsmema, METH_VARARGS, "\n"
21041 "Set the memory area to be plotted (RGBA)\n"
21042 "\n"
21043 "DESCRIPTION:\n"
21044 "\n"
21045 " Set the memory area to be plotted (with the memcairo driver) as the\n"
21046 " dev member of the stream structure. Also set the number of pixels in\n"
21047 " the memory passed in\n"
21048 " plotmem, which is a block of memory\n"
21049 " maxy by\n"
21050 " maxx by 4 bytes long, say: 480 x 640 x 4 (Y, X, RGBA)\n"
21051 "\n"
21052 " This memory will have to be freed by the user!\n"
21053 "\n"
21054 " Redacted form: plsmema(maxx, maxy, plotmem)\n"
21055 "\n"
21056 " This function is not used in any examples.\n"
21057 "\n"
21058 "\n"
21059 "\n"
21060 "SYNOPSIS:\n"
21061 "\n"
21062 "plsmema(maxx, maxy, plotmem)\n"
21063 "\n"
21064 "ARGUMENTS:\n"
21065 "\n"
21066 " maxx (PLINT, input) : Size of memory area in the X coordinate.\n"
21067 "\n"
21068 " maxy (PLINT, input) : Size of memory area in the Y coordinate.\n"
21069 "\n"
21070 " plotmem (PLPointer, input) : Pointer to the beginning of a\n"
21071 " user-supplied writeable memory area.\n"
21072 "\n"
21073 ""},
21074 { "plsmin", _wrap_plsmin, METH_VARARGS, "\n"
21075 "Set length of minor ticks\n"
21076 "\n"
21077 "DESCRIPTION:\n"
21078 "\n"
21079 " This sets up the length of the minor ticks and the length of the\n"
21080 " terminals on error bars. The actual length is the product of the\n"
21081 " default length and a scaling factor as for character height.\n"
21082 "\n"
21083 " Redacted form: plsmin(def, scale)\n"
21084 "\n"
21085 " This function is used in example 29.\n"
21086 "\n"
21087 "\n"
21088 "\n"
21089 "SYNOPSIS:\n"
21090 "\n"
21091 "plsmin(def, scale)\n"
21092 "\n"
21093 "ARGUMENTS:\n"
21094 "\n"
21095 " def (PLFLT, input) : The default length of a minor tick in\n"
21096 " millimeters, should be set to zero if the default length is to\n"
21097 " remain unchanged.\n"
21098 "\n"
21099 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21100 " actual tick length.\n"
21101 "\n"
21102 ""},
21103 { "plsori", _wrap_plsori, METH_O, "\n"
21104 "Set orientation\n"
21105 "\n"
21106 "DESCRIPTION:\n"
21107 "\n"
21108 " Set integer plot orientation parameter. This function is identical to\n"
21109 " plsdiori except for the type of the argument, and should be used in\n"
21110 " the same way. See the documentation of plsdiori for details.\n"
21111 "\n"
21112 " Redacted form: plsori(ori)\n"
21113 "\n"
21114 " This function is used in example 3.\n"
21115 "\n"
21116 "\n"
21117 "\n"
21118 "SYNOPSIS:\n"
21119 "\n"
21120 "plsori(ori)\n"
21121 "\n"
21122 "ARGUMENTS:\n"
21123 "\n"
21124 " ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n"
21125 " portrait, etc.) The value is multiplied by 90 degrees to get the\n"
21126 " angle.\n"
21127 "\n"
21128 ""},
21129 { "plspage", _wrap_plspage, METH_VARARGS, "\n"
21130 "Set page parameters\n"
21131 "\n"
21132 "DESCRIPTION:\n"
21133 "\n"
21134 " Sets the page configuration (optional). If an individual parameter is\n"
21135 " zero then that parameter value is not updated. Not all parameters are\n"
21136 " recognized by all drivers and the interpretation is device-dependent.\n"
21137 " The X-window driver uses the length and offset parameters to determine\n"
21138 " the window size and location. The length and offset values are\n"
21139 " expressed in units that are specific to the current driver. For\n"
21140 " instance: screen drivers will usually interpret them as number of\n"
21141 " pixels, whereas printer drivers will usually use mm.\n"
21142 "\n"
21143 " This routine, if used, must be called before initializing PLplot. It\n"
21144 " may be called at later times for interactive drivers to change only\n"
21145 " the dpi for subsequent redraws which you can force via a call to\n"
21146 " plreplot. If this function is not called then the page size defaults\n"
21147 " to landscape A4 for drivers which use real world page sizes and 744\n"
21148 " pixels wide by 538 pixels high for raster drivers. The default value\n"
21149 " for dx and dy is 90 pixels per inch for raster drivers.\n"
21150 "\n"
21151 "\n"
21152 "\n"
21153 " Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21154 "\n"
21155 " This function is used in examples 14 and 31.\n"
21156 "\n"
21157 "\n"
21158 "\n"
21159 "SYNOPSIS:\n"
21160 "\n"
21161 "plspage(xp, yp, xleng, yleng, xoff, yoff)\n"
21162 "\n"
21163 "ARGUMENTS:\n"
21164 "\n"
21165 " xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n"
21166 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21167 " (e.g. mm).\n"
21168 "\n"
21169 " yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n"
21170 " by raster drivers, ignored by drivers which use \"real world\" units\n"
21171 " (e.g. mm).\n"
21172 "\n"
21173 " xleng (PLINT, input) : Page length, x.\n"
21174 "\n"
21175 " yleng (PLINT, input) : Page length, y.\n"
21176 "\n"
21177 " xoff (PLINT, input) : Page offset, x.\n"
21178 "\n"
21179 " yoff (PLINT, input) : Page offset, y.\n"
21180 "\n"
21181 ""},
21182 { "plspal0", _wrap_plspal0, METH_O, "\n"
21183 "Set the cmap0 palette using the specified cmap0*.pal format file\n"
21184 "\n"
21185 "DESCRIPTION:\n"
21186 "\n"
21187 " Set the cmap0 palette using the specified cmap0*.pal format file.\n"
21188 "\n"
21189 " Redacted form: plspal0(filename)\n"
21190 "\n"
21191 " This function is in example 16.\n"
21192 "\n"
21193 "\n"
21194 "\n"
21195 "SYNOPSIS:\n"
21196 "\n"
21197 "plspal0(filename)\n"
21198 "\n"
21199 "ARGUMENTS:\n"
21200 "\n"
21201 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21202 " containing the name of the cmap0*.pal file. If this string is\n"
21203 " empty, use the default cmap0*.pal file.\n"
21204 "\n"
21205 ""},
21206 { "plspal1", _wrap_plspal1, METH_VARARGS, "\n"
21207 "Set the cmap1 palette using the specified cmap1*.pal format file\n"
21208 "\n"
21209 "DESCRIPTION:\n"
21210 "\n"
21211 " Set the cmap1 palette using the specified cmap1*.pal format file.\n"
21212 "\n"
21213 " Redacted form: plspal1(filename, interpolate)\n"
21214 "\n"
21215 " This function is used in example 16.\n"
21216 "\n"
21217 "\n"
21218 "\n"
21219 "SYNOPSIS:\n"
21220 "\n"
21221 "plspal1(filename, interpolate)\n"
21222 "\n"
21223 "ARGUMENTS:\n"
21224 "\n"
21225 " filename (PLCHAR_VECTOR, input) : An ascii character string\n"
21226 " containing the name of the cmap1*.pal file. If this string is\n"
21227 " empty, use the default cmap1*.pal file.\n"
21228 "\n"
21229 " interpolate (PLBOOL, input) : If this parameter is true, the\n"
21230 " columns containing the intensity index, r, g, b, alpha and\n"
21231 " alt_hue_path in the cmap1*.pal file are used to set the cmap1\n"
21232 " palette with a call to plscmap1la. (The cmap1*.pal header contains\n"
21233 " a flag which controls whether the r, g, b data sent to plscmap1la\n"
21234 " are interpreted as HLS or RGB.) If this parameter is false, the\n"
21235 " intensity index and alt_hue_path columns are ignored and the r, g,\n"
21236 " b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n"
21237 " are used instead to set the cmap1 palette directly with a call to\n"
21238 " plscmap1a.\n"
21239 "\n"
21240 ""},
21241 { "plspause", _wrap_plspause, METH_O, "\n"
21242 "Set the pause (on end-of-page) status\n"
21243 "\n"
21244 "DESCRIPTION:\n"
21245 "\n"
21246 " Set the pause (on end-of-page) status.\n"
21247 "\n"
21248 " Redacted form: plspause(pause)\n"
21249 "\n"
21250 " This function is in examples 14,20.\n"
21251 "\n"
21252 "\n"
21253 "\n"
21254 "SYNOPSIS:\n"
21255 "\n"
21256 "plspause(pause)\n"
21257 "\n"
21258 "ARGUMENTS:\n"
21259 "\n"
21260 " pause (PLBOOL, input) : If pause is true there will be a pause on\n"
21261 " end-of-page for those drivers which support this. Otherwise there\n"
21262 " is no pause.\n"
21263 "\n"
21264 ""},
21265 { "plsstrm", _wrap_plsstrm, METH_O, "\n"
21266 "Set current output stream\n"
21267 "\n"
21268 "DESCRIPTION:\n"
21269 "\n"
21270 " Sets the number of the current output stream. The stream number\n"
21271 " defaults to 0 unless changed by this routine. The first use of this\n"
21272 " routine must be followed by a call initializing PLplot (e.g. plstar).\n"
21273 "\n"
21274 " Redacted form: plsstrm(strm)\n"
21275 "\n"
21276 " This function is examples 1,14,20.\n"
21277 "\n"
21278 "\n"
21279 "\n"
21280 "SYNOPSIS:\n"
21281 "\n"
21282 "plsstrm(strm)\n"
21283 "\n"
21284 "ARGUMENTS:\n"
21285 "\n"
21286 " strm (PLINT, input) : The current stream number.\n"
21287 "\n"
21288 ""},
21289 { "plssub", _wrap_plssub, METH_VARARGS, "\n"
21290 "Set the number of subpages in x and y\n"
21291 "\n"
21292 "DESCRIPTION:\n"
21293 "\n"
21294 " Set the number of subpages in x and y.\n"
21295 "\n"
21296 " Redacted form: plssub(nx, ny)\n"
21297 "\n"
21298 " This function is examples 1,2,14,21,25,27.\n"
21299 "\n"
21300 "\n"
21301 "\n"
21302 "SYNOPSIS:\n"
21303 "\n"
21304 "plssub(nx, ny)\n"
21305 "\n"
21306 "ARGUMENTS:\n"
21307 "\n"
21308 " nx (PLINT, input) : Number of windows in x direction (i.e., number\n"
21309 " of window columns).\n"
21310 "\n"
21311 " ny (PLINT, input) : Number of windows in y direction (i.e., number\n"
21312 " of window rows).\n"
21313 "\n"
21314 ""},
21315 { "plssym", _wrap_plssym, METH_VARARGS, "\n"
21316 "Set symbol size\n"
21317 "\n"
21318 "DESCRIPTION:\n"
21319 "\n"
21320 " This sets up the size of all subsequent symbols drawn by plpoin and\n"
21321 " plsym. The actual height of a symbol is the product of the default\n"
21322 " symbol size and a scaling factor as for the character height.\n"
21323 "\n"
21324 " Redacted form: plssym(def, scale)\n"
21325 "\n"
21326 " This function is used in example 29.\n"
21327 "\n"
21328 "\n"
21329 "\n"
21330 "SYNOPSIS:\n"
21331 "\n"
21332 "plssym(def, scale)\n"
21333 "\n"
21334 "ARGUMENTS:\n"
21335 "\n"
21336 " def (PLFLT, input) : The default height of a symbol in millimeters,\n"
21337 " should be set to zero if the default height is to remain\n"
21338 " unchanged.\n"
21339 "\n"
21340 " scale (PLFLT, input) : Scale factor to be applied to default to get\n"
21341 " actual symbol height.\n"
21342 "\n"
21343 ""},
21344 { "plstar", _wrap_plstar, METH_VARARGS, "\n"
21345 "Initialization\n"
21346 "\n"
21347 "DESCRIPTION:\n"
21348 "\n"
21349 " Initializing the plotting package. The program prompts for the device\n"
21350 " keyword or number of the desired output device. Hitting a RETURN in\n"
21351 " response to the prompt is the same as selecting the first device. If\n"
21352 " only one device is enabled when PLplot is installed, plstar will issue\n"
21353 " no prompt. The output device is divided into nx by ny subpages, each\n"
21354 " of which may be used independently. The subroutine pladv is used to\n"
21355 " advance from one subpage to the next.\n"
21356 "\n"
21357 " Redacted form: plstar(nx, ny)\n"
21358 "\n"
21359 " This function is used in example 1.\n"
21360 "\n"
21361 "\n"
21362 "\n"
21363 "SYNOPSIS:\n"
21364 "\n"
21365 "plstar(nx, ny)\n"
21366 "\n"
21367 "ARGUMENTS:\n"
21368 "\n"
21369 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21370 " x direction.\n"
21371 "\n"
21372 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21373 " y direction.\n"
21374 "\n"
21375 ""},
21376 { "plstart", _wrap_plstart, METH_VARARGS, "\n"
21377 "Initialization\n"
21378 "\n"
21379 "DESCRIPTION:\n"
21380 "\n"
21381 " Alternative to plstar for initializing the plotting package. The\n"
21382 " device name keyword for the desired output device must be supplied as\n"
21383 " an argument. These keywords are the same as those printed out by\n"
21384 " plstar. If the requested device is not available, or if the input\n"
21385 " string is empty or begins with ``?'', the prompted start up of plstar\n"
21386 " is used. This routine also divides the output device page into nx by\n"
21387 " ny subpages, each of which may be used independently. The subroutine\n"
21388 " pladv is used to advance from one subpage to the next.\n"
21389 "\n"
21390 " Redacted form: General: plstart(devname, nx, ny)\n"
21391 "\n"
21392 "\n"
21393 " This function is not used in any examples.\n"
21394 "\n"
21395 "\n"
21396 "\n"
21397 "SYNOPSIS:\n"
21398 "\n"
21399 "plstart(devname, nx, ny)\n"
21400 "\n"
21401 "ARGUMENTS:\n"
21402 "\n"
21403 " devname (PLCHAR_VECTOR, input) : An ascii character string\n"
21404 " containing the device name keyword of the required output device.\n"
21405 " If\n"
21406 " devname is NULL or if the first character of the string is a ``?'',\n"
21407 " the normal (prompted) start up is used.\n"
21408 "\n"
21409 " nx (PLINT, input) : Number of subpages to divide output page in the\n"
21410 " x direction.\n"
21411 "\n"
21412 " ny (PLINT, input) : Number of subpages to divide output page in the\n"
21413 " y direction.\n"
21414 "\n"
21415 ""},
21416 { "plstransform", _wrap_plstransform, METH_VARARGS, "\n"
21417 "Set a global coordinate transform function\n"
21418 "\n"
21419 "DESCRIPTION:\n"
21420 "\n"
21421 " This function can be used to define a coordinate transformation which\n"
21422 " affects all elements drawn within the current plot window. The\n"
21423 " coordinate_transform callback function is similar to that provided for\n"
21424 " the plmap and plmeridians functions. The coordinate_transform_data\n"
21425 " parameter may be used to pass extra data to coordinate_transform.\n"
21426 "\n"
21427 " Redacted form: General: plstransform(coordinate_transform,\n"
21428 " coordinate_transform_data)\n"
21429 "\n"
21430 "\n"
21431 " This function is used in examples 19 and 22.\n"
21432 "\n"
21433 "\n"
21434 "\n"
21435 "SYNOPSIS:\n"
21436 "\n"
21437 "plstransform(coordinate_transform, coordinate_transform_data)\n"
21438 "\n"
21439 "ARGUMENTS:\n"
21440 "\n"
21441 " coordinate_transform (PLTRANSFORM_callback, input) : A callback\n"
21442 " function that defines the transformation from the input (x, y)\n"
21443 " world coordinates to new PLplot world coordinates. If\n"
21444 " coordinate_transform is not supplied (e.g., is set to NULL in the C\n"
21445 " case), then no transform is applied.\n"
21446 "\n"
21447 " coordinate_transform_data (PLPointer, input) : Optional extra data\n"
21448 " for\n"
21449 " coordinate_transform.\n"
21450 "\n"
21451 ""},
21452 { "plstring", _wrap_plstring, METH_VARARGS, "\n"
21453 "Plot a glyph at the specified points\n"
21454 "\n"
21455 "DESCRIPTION:\n"
21456 "\n"
21457 " Plot a glyph at the specified points. (Supersedes plpoin and plsym\n"
21458 " because many[!] more glyphs are accessible with plstring.) The glyph\n"
21459 " is specified with a PLplot user string. Note that the user string is\n"
21460 " not actually limited to one glyph so it is possible (but not normally\n"
21461 " useful) to plot more than one glyph at the specified points with this\n"
21462 " function. As with plmtex and plptex, the user string can contain FCI\n"
21463 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21464 " else PLplot escapes for Hershey or unicode text to determine the\n"
21465 " glyph.\n"
21466 "\n"
21467 " Redacted form: plstring(x, y, string)\n"
21468 "\n"
21469 " This function is used in examples 4, 21 and 26.\n"
21470 "\n"
21471 "\n"
21472 "\n"
21473 "SYNOPSIS:\n"
21474 "\n"
21475 "plstring(n, x, y, string)\n"
21476 "\n"
21477 "ARGUMENTS:\n"
21478 "\n"
21479 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21480 "\n"
21481 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21482 " the points.\n"
21483 "\n"
21484 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21485 " the points.\n"
21486 "\n"
21487 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21488 " the glyph(s) to be plotted at each of the n points.\n"
21489 "\n"
21490 ""},
21491 { "plstring3", _wrap_plstring3, METH_VARARGS, "\n"
21492 "Plot a glyph at the specified 3D points\n"
21493 "\n"
21494 "DESCRIPTION:\n"
21495 "\n"
21496 " Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n"
21497 " many[!] more glyphs are accessible with plstring3.) Set up the call to\n"
21498 " this function similar to what is done for plline3. The glyph is\n"
21499 " specified with a PLplot user string. Note that the user string is not\n"
21500 " actually limited to one glyph so it is possible (but not normally\n"
21501 " useful) to plot more than one glyph at the specified points with this\n"
21502 " function. As with plmtex and plptex, the user string can contain FCI\n"
21503 " escapes to determine the font, UTF-8 code to determine the glyph or\n"
21504 " else PLplot escapes for Hershey or unicode text to determine the\n"
21505 " glyph.\n"
21506 "\n"
21507 " Redacted form: plstring3(x, y, z, string)\n"
21508 "\n"
21509 " This function is used in example 18.\n"
21510 "\n"
21511 "\n"
21512 "\n"
21513 "SYNOPSIS:\n"
21514 "\n"
21515 "plstring3(n, x, y, z, string)\n"
21516 "\n"
21517 "ARGUMENTS:\n"
21518 "\n"
21519 " n (PLINT, input) : Number of points in the x, y, and z vectors.\n"
21520 "\n"
21521 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21522 " the points.\n"
21523 "\n"
21524 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21525 " the points.\n"
21526 "\n"
21527 " z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n"
21528 " the points.\n"
21529 "\n"
21530 " string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21531 " the glyph(s) to be plotted at each of the n points. points.\n"
21532 "\n"
21533 ""},
21534 { "plstripa", _wrap_plstripa, METH_VARARGS, "\n"
21535 "Add a point to a strip chart\n"
21536 "\n"
21537 "DESCRIPTION:\n"
21538 "\n"
21539 " Add a point to a given pen of a given strip chart. There is no need\n"
21540 " for all pens to have the same number of points or to be equally\n"
21541 " sampled in the x coordinate. Allocates memory and rescales as\n"
21542 " necessary.\n"
21543 "\n"
21544 " Redacted form: plstripa(id, pen, x, y)\n"
21545 "\n"
21546 " This function is used in example 17.\n"
21547 "\n"
21548 "\n"
21549 "\n"
21550 "SYNOPSIS:\n"
21551 "\n"
21552 "plstripa(id, pen, x, y)\n"
21553 "\n"
21554 "ARGUMENTS:\n"
21555 "\n"
21556 " id (PLINT, input) : Identification number of the strip chart (set\n"
21557 " up in plstripc).\n"
21558 "\n"
21559 " pen (PLINT, input) : Pen number (ranges from 0 to 3).\n"
21560 "\n"
21561 " x (PLFLT, input) : X coordinate of point to plot.\n"
21562 "\n"
21563 " y (PLFLT, input) : Y coordinate of point to plot.\n"
21564 "\n"
21565 ""},
21566 { "plstripc", _wrap_plstripc, METH_VARARGS, "\n"
21567 "Create a 4-pen strip chart\n"
21568 "\n"
21569 "DESCRIPTION:\n"
21570 "\n"
21571 " Create a 4-pen strip chart, to be used afterwards by plstripa\n"
21572 "\n"
21573 " Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n"
21574 " ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n"
21575 " styline, legline, labx, laby, labz)\n"
21576 "\n"
21577 "\n"
21578 " This function is used in example 17.\n"
21579 "\n"
21580 "\n"
21581 "\n"
21582 "SYNOPSIS:\n"
21583 "\n"
21584 "plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n"
21585 "\n"
21586 "ARGUMENTS:\n"
21587 "\n"
21588 " id (PLINT_NC_SCALAR, output) : Returned value of the identification\n"
21589 " number of the strip chart to use on plstripa and plstripd.\n"
21590 "\n"
21591 " xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21592 " the x-axis specification as in plbox.\n"
21593 "\n"
21594 " yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n"
21595 " the y-axis specification as in plbox.\n"
21596 "\n"
21597 " xmin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21598 " change as data are added.\n"
21599 "\n"
21600 " xmax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21601 " change as data are added.\n"
21602 "\n"
21603 " xjump (PLFLT, input) : When x attains xmax, the length of the plot\n"
21604 " is multiplied by the factor (1 +\n"
21605 " xjump) .\n"
21606 "\n"
21607 " ymin (PLFLT, input) : Initial coordinates of plot box; they will\n"
21608 " change as data are added.\n"
21609 "\n"
21610 " ymax (PLFLT, input) : Initial coordinates of plot box; they will\n"
21611 " change as data are added.\n"
21612 "\n"
21613 " xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n"
21614 "\n"
21615 " ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n"
21616 "\n"
21617 " y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n"
21618 " true, otherwise not.\n"
21619 "\n"
21620 " acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n"
21621 " otherwise slide display.\n"
21622 "\n"
21623 " colbox (PLINT, input) : Plot box color index (cmap0).\n"
21624 "\n"
21625 " collab (PLINT, input) : Legend color index (cmap0).\n"
21626 "\n"
21627 " colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n"
21628 " indices for the 4 pens.\n"
21629 "\n"
21630 " styline (PLINT_VECTOR, input) : A vector containing the line style\n"
21631 " indices for the 4 pens.\n"
21632 "\n"
21633 " legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n"
21634 " strings containing legends for the 4 pens.\n"
21635 "\n"
21636 " labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21637 " the label for the x axis.\n"
21638 "\n"
21639 " laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21640 " the label for the y axis.\n"
21641 "\n"
21642 " labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n"
21643 " the plot title.\n"
21644 "\n"
21645 ""},
21646 { "plstripd", _wrap_plstripd, METH_O, "\n"
21647 "Deletes and releases memory used by a strip chart\n"
21648 "\n"
21649 "DESCRIPTION:\n"
21650 "\n"
21651 " Deletes and releases memory used by a strip chart.\n"
21652 "\n"
21653 " Redacted form: plstripd(id)\n"
21654 "\n"
21655 " This function is used in example 17.\n"
21656 "\n"
21657 "\n"
21658 "\n"
21659 "SYNOPSIS:\n"
21660 "\n"
21661 "plstripd(id)\n"
21662 "\n"
21663 "ARGUMENTS:\n"
21664 "\n"
21665 " id (PLINT, input) : Identification number of strip chart to delete.\n"
21666 "\n"
21667 ""},
21668 { "plstyl", _wrap_plstyl, METH_VARARGS, "\n"
21669 "Set line style\n"
21670 "\n"
21671 "DESCRIPTION:\n"
21672 "\n"
21673 " This sets up the line style for all lines subsequently drawn. A line\n"
21674 " consists of segments in which the pen is alternately down and up. The\n"
21675 " lengths of these segments are passed in the vectors mark and space\n"
21676 " respectively. The number of mark-space pairs is specified by nms. In\n"
21677 " order to return the line style to the default continuous line, plstyl\n"
21678 " should be called with nms =0 .(see also pllsty)\n"
21679 "\n"
21680 " Redacted form: plstyl(mark, space)\n"
21681 "\n"
21682 " This function is used in examples 1, 9, and 14.\n"
21683 "\n"
21684 "\n"
21685 "\n"
21686 "SYNOPSIS:\n"
21687 "\n"
21688 "plstyl(nms, mark, space)\n"
21689 "\n"
21690 "ARGUMENTS:\n"
21691 "\n"
21692 " nms (PLINT, input) : The number of mark and space elements in a\n"
21693 " line. Thus a simple broken line can be obtained by setting nms=1\n"
21694 " . A continuous line is specified by setting nms=0 .\n"
21695 "\n"
21696 " mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n"
21697 " segments during which the pen is down, measured in micrometers.\n"
21698 "\n"
21699 " space (PLINT_VECTOR, input) : A vector containing the lengths of\n"
21700 " the segments during which the pen is up, measured in micrometers.\n"
21701 "\n"
21702 ""},
21703 { "plsvect", _wrap_plsvect, METH_VARARGS, "\n"
21704 "Set arrow style for vector plots\n"
21705 "\n"
21706 "DESCRIPTION:\n"
21707 "\n"
21708 " Set the style for the arrow used by plvect to plot vectors.\n"
21709 "\n"
21710 " Redacted form: plsvect(arrowx, arrowy, fill)\n"
21711 "\n"
21712 " This function is used in example 22.\n"
21713 "\n"
21714 "\n"
21715 "\n"
21716 "SYNOPSIS:\n"
21717 "\n"
21718 "plsvect(arrowx, arrowy, npts, fill)\n"
21719 "\n"
21720 "ARGUMENTS:\n"
21721 "\n"
21722 " arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n"
21723 " the x and y points which make up the arrow. The arrow is plotted\n"
21724 " by joining these points to form a polygon. The scaling assumes\n"
21725 " that the x and y points in the arrow lie in the range -0.5 <= x,y\n"
21726 " <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n"
21727 " will be reset to its default.\n"
21728 "\n"
21729 " npts (PLINT, input) : Number of points in the vectors arrowx and\n"
21730 " arrowy.\n"
21731 "\n"
21732 " fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n"
21733 " fill is false then the arrow is open.\n"
21734 "\n"
21735 ""},
21736 { "plsvpa", _wrap_plsvpa, METH_VARARGS, "\n"
21737 "Specify viewport in absolute coordinates\n"
21738 "\n"
21739 "DESCRIPTION:\n"
21740 "\n"
21741 " Alternate routine to plvpor for setting up the viewport. This routine\n"
21742 " should be used only if the viewport is required to have a definite\n"
21743 " size in millimeters. The routine plgspa is useful for finding out the\n"
21744 " size of the current subpage.\n"
21745 "\n"
21746 " Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n"
21747 "\n"
21748 " This function is used in example 10.\n"
21749 "\n"
21750 "\n"
21751 "\n"
21752 "SYNOPSIS:\n"
21753 "\n"
21754 "plsvpa(xmin, xmax, ymin, ymax)\n"
21755 "\n"
21756 "ARGUMENTS:\n"
21757 "\n"
21758 " xmin (PLFLT, input) : The distance of the left-hand edge of the\n"
21759 " viewport from the left-hand edge of the subpage in millimeters.\n"
21760 "\n"
21761 " xmax (PLFLT, input) : The distance of the right-hand edge of the\n"
21762 " viewport from the left-hand edge of the subpage in millimeters.\n"
21763 "\n"
21764 " ymin (PLFLT, input) : The distance of the bottom edge of the\n"
21765 " viewport from the bottom edge of the subpage in millimeters.\n"
21766 "\n"
21767 " ymax (PLFLT, input) : The distance of the top edge of the viewport\n"
21768 " from the bottom edge of the subpage in millimeters.\n"
21769 "\n"
21770 ""},
21771 { "plsxax", _wrap_plsxax, METH_VARARGS, "\n"
21772 "Set x axis parameters\n"
21773 "\n"
21774 "DESCRIPTION:\n"
21775 "\n"
21776 " Sets values of the digmax and digits flags for the x axis. See the\n"
21777 " PLplot documentation for more information.\n"
21778 "\n"
21779 " Redacted form: plsxax(digmax, digits)\n"
21780 "\n"
21781 " This function is used in example 31.\n"
21782 "\n"
21783 "\n"
21784 "\n"
21785 "SYNOPSIS:\n"
21786 "\n"
21787 "plsxax(digmax, digits)\n"
21788 "\n"
21789 "ARGUMENTS:\n"
21790 "\n"
21791 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21792 " digits for the x axis. If nonzero, the printed label will be\n"
21793 " switched to a floating-point representation when the number of\n"
21794 " digits exceeds digmax.\n"
21795 "\n"
21796 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21797 " its value here has no effect since it is set only by plbox or\n"
21798 " plbox3. However, the user may obtain its value after a call to\n"
21799 " either of these functions by calling plgxax.\n"
21800 "\n"
21801 ""},
21802 { "plsyax", _wrap_plsyax, METH_VARARGS, "\n"
21803 "Set y axis parameters\n"
21804 "\n"
21805 "DESCRIPTION:\n"
21806 "\n"
21807 " Identical to plsxax, except that arguments are flags for y axis. See\n"
21808 " the description of plsxax for more detail.\n"
21809 "\n"
21810 " Redacted form: plsyax(digmax, digits)\n"
21811 "\n"
21812 " This function is used in examples 1, 14, and 31.\n"
21813 "\n"
21814 "\n"
21815 "\n"
21816 "SYNOPSIS:\n"
21817 "\n"
21818 "plsyax(digmax, digits)\n"
21819 "\n"
21820 "ARGUMENTS:\n"
21821 "\n"
21822 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21823 " digits for the y axis. If nonzero, the printed label will be\n"
21824 " switched to a floating-point representation when the number of\n"
21825 " digits exceeds digmax.\n"
21826 "\n"
21827 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21828 " its value here has no effect since it is set only by plbox or\n"
21829 " plbox3. However, the user may obtain its value after a call to\n"
21830 " either of these functions by calling plgyax.\n"
21831 "\n"
21832 ""},
21833 { "plsym", _wrap_plsym, METH_VARARGS, "\n"
21834 "Plot a glyph at the specified points\n"
21835 "\n"
21836 "DESCRIPTION:\n"
21837 "\n"
21838 " Plot a glyph at the specified points. (This function is largely\n"
21839 " superseded by plstring which gives access to many[!] more glyphs.)\n"
21840 "\n"
21841 " Redacted form: plsym(x, y, code)\n"
21842 "\n"
21843 " This function is used in example 7.\n"
21844 "\n"
21845 "\n"
21846 "\n"
21847 "SYNOPSIS:\n"
21848 "\n"
21849 "plsym(n, x, y, code)\n"
21850 "\n"
21851 "ARGUMENTS:\n"
21852 "\n"
21853 " n (PLINT, input) : Number of points in the x and y vectors.\n"
21854 "\n"
21855 " x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n"
21856 " the points.\n"
21857 "\n"
21858 " y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n"
21859 " the points.\n"
21860 "\n"
21861 " code (PLINT, input) : Hershey symbol code corresponding to a glyph\n"
21862 " to be plotted at each of the n points.\n"
21863 "\n"
21864 ""},
21865 { "plszax", _wrap_plszax, METH_VARARGS, "\n"
21866 "Set z axis parameters\n"
21867 "\n"
21868 "DESCRIPTION:\n"
21869 "\n"
21870 " Identical to plsxax, except that arguments are flags for z axis. See\n"
21871 " the description of plsxax for more detail.\n"
21872 "\n"
21873 " Redacted form: plszax(digmax, digits)\n"
21874 "\n"
21875 " This function is used in example 31.\n"
21876 "\n"
21877 "\n"
21878 "\n"
21879 "SYNOPSIS:\n"
21880 "\n"
21881 "plszax(digmax, digits)\n"
21882 "\n"
21883 "ARGUMENTS:\n"
21884 "\n"
21885 " digmax (PLINT, input) : Variable to set the maximum number of\n"
21886 " digits for the z axis. If nonzero, the printed label will be\n"
21887 " switched to a floating-point representation when the number of\n"
21888 " digits exceeds digmax.\n"
21889 "\n"
21890 " digits (PLINT, input) : Field digits value. Currently, changing\n"
21891 " its value here has no effect since it is set only by plbox or\n"
21892 " plbox3. However, the user may obtain its value after a call to\n"
21893 " either of these functions by calling plgzax.\n"
21894 "\n"
21895 ""},
21896 { "pltext", _wrap_pltext, METH_NOARGS, "\n"
21897 "Switch to text screen\n"
21898 "\n"
21899 "DESCRIPTION:\n"
21900 "\n"
21901 " Sets an interactive device to text mode, used in conjunction with\n"
21902 " plgra to allow graphics and text to be interspersed. On a device\n"
21903 " which supports separate text and graphics windows, this command causes\n"
21904 " control to be switched to the text window. This can be useful for\n"
21905 " printing diagnostic messages or getting user input, which would\n"
21906 " otherwise interfere with the plots. The program must switch back to\n"
21907 " the graphics window before issuing plot commands, as the text (or\n"
21908 " console) device will probably become quite confused otherwise. If\n"
21909 " already in text mode, this command is ignored. It is also ignored on\n"
21910 " devices which only support a single window or use a different method\n"
21911 " for shifting focus (see also plgra).\n"
21912 "\n"
21913 " Redacted form: pltext()\n"
21914 "\n"
21915 " This function is used in example 1.\n"
21916 "\n"
21917 "\n"
21918 "\n"
21919 "SYNOPSIS:\n"
21920 "\n"
21921 "pltext()\n"
21922 "\n"
21923 ""},
21924 { "pltimefmt", _wrap_pltimefmt, METH_O, "\n"
21925 "Set format for date / time labels\n"
21926 "\n"
21927 "DESCRIPTION:\n"
21928 "\n"
21929 " Sets the format for date / time labels. To enable date / time format\n"
21930 " labels see the options to plbox, plbox3, and plenv.\n"
21931 "\n"
21932 " Redacted form: pltimefmt(fmt)\n"
21933 "\n"
21934 " This function is used in example 29.\n"
21935 "\n"
21936 "\n"
21937 "\n"
21938 "SYNOPSIS:\n"
21939 "\n"
21940 "pltimefmt(fmt)\n"
21941 "\n"
21942 "ARGUMENTS:\n"
21943 "\n"
21944 " fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n"
21945 " interpreted similarly to the format specifier of typical system\n"
21946 " strftime routines except that PLplot ignores locale and also\n"
21947 " supplies some useful extensions in the context of plotting. All\n"
21948 " text in the string is printed as-is other than conversion\n"
21949 " specifications which take the form of a '%' character followed by\n"
21950 " further conversion specification character. The conversion\n"
21951 " specifications which are similar to those provided by system\n"
21952 " strftime routines are the following: %a: The abbreviated (English)\n"
21953 " weekday name.\n"
21954 " %A: The full (English) weekday name.\n"
21955 " %b: The abbreviated (English) month name.\n"
21956 " %B: The full (English) month name.\n"
21957 " %c: Equivalent to %a %b %d %T %Y (non-ISO).\n"
21958 " %C: The century number (year/100) as a 2-digit integer.\n"
21959 " %d: The day of the month as a decimal number (range 01 to 31).\n"
21960 " %D: Equivalent to %m/%d/%y (non-ISO).\n"
21961 " %e: Like %d, but a leading zero is replaced by a space.\n"
21962 " %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n"
21963 " %h: Equivalent to %b.\n"
21964 " %H: The hour as a decimal number using a 24-hour clock (range\n"
21965 " 00 to 23).\n"
21966 " %I: The hour as a decimal number using a 12-hour clock (range\n"
21967 " 01 to 12).\n"
21968 " %j: The day of the year as a decimal number (range 001 to\n"
21969 " 366).\n"
21970 " %k: The hour (24-hour clock) as a decimal number (range 0 to\n"
21971 " 23); single digits are preceded by a blank. (See also %H.)\n"
21972 " %l: The hour (12-hour clock) as a decimal number (range 1 to\n"
21973 " 12); single digits are preceded by a blank. (See also %I.)\n"
21974 " %m: The month as a decimal number (range 01 to 12).\n"
21975 " %M: The minute as a decimal number (range 00 to 59).\n"
21976 " %n: A newline character.\n"
21977 " %p: Either \"AM\" or \"PM\" according to the given time value.\n"
21978 " Noon is treated as \"PM\" and midnight as \"AM\".\n"
21979 " %r: Equivalent to %I:%M:%S %p.\n"
21980 " %R: The time in 24-hour notation (%H:%M). For a version\n"
21981 " including the seconds, see %T below.\n"
21982 " %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n"
21983 " +0000 (UTC).\n"
21984 " %S: The second as a decimal number (range 00 to 60). (The\n"
21985 " range is up to 60 to allow for occasional leap seconds.)\n"
21986 " %t: A tab character.\n"
21987 " %T: The time in 24-hour notation (%H:%M:%S).\n"
21988 " %u: The day of the week as a decimal, range 1 to 7, Monday\n"
21989 " being 1. See also %w.\n"
21990 " %U: The week number of the current year as a decimal number,\n"
21991 " range 00 to 53, starting with the first Sunday as the first\n"
21992 " day of week 01. See also %V and %W.\n"
21993 " %v: Equivalent to %e-%b-%Y.\n"
21994 " %V: The ISO 8601 week number of the current year as a decimal\n"
21995 " number, range 01 to 53, where week 1 is the first week that\n"
21996 " has at least 4 days in the new year. See also %U and %W.\n"
21997 " %w: The day of the week as a decimal, range 0 to 6, Sunday\n"
21998 " being 0. See also %u.\n"
21999 " %W: The week number of the current year as a decimal number,\n"
22000 " range 00 to 53, starting with the first Monday as the first\n"
22001 " day of week 01.\n"
22002 " %x: Equivalent to %a %b %d %Y.\n"
22003 " %X: Equivalent to %T.\n"
22004 " %y: The year as a decimal number without a century (range 00\n"
22005 " to 99).\n"
22006 " %Y: The year as a decimal number including a century.\n"
22007 " %z: The UTC time-zone string = \"+0000\".\n"
22008 " %Z: The UTC time-zone abbreviation = \"UTC\".\n"
22009 " %+: The UTC date and time in default format of the Unix date\n"
22010 " command which is equivalent to %a %b %d %T %Z %Y.\n"
22011 " %%: A literal \"%\" character.\n"
22012 " The conversion specifications which are extensions to those normally\n"
22013 " provided by system strftime routines are the following: %(0-9):\n"
22014 " The fractional part of the seconds field (including leading\n"
22015 " decimal point) to the specified accuracy. Thus %S%3 would give\n"
22016 " seconds to millisecond accuracy (00.000).\n"
22017 " %.: The fractional part of the seconds field (including\n"
22018 " leading decimal point) to the maximum available accuracy. Thus\n"
22019 " %S%. would give seconds with fractional part up to 9 decimal\n"
22020 " places if available.\n"
22021 "\n"
22022 ""},
22023 { "plvasp", _wrap_plvasp, METH_O, "\n"
22024 "Specify viewport using aspect ratio only\n"
22025 "\n"
22026 "DESCRIPTION:\n"
22027 "\n"
22028 " Selects the largest viewport with the given aspect ratio within the\n"
22029 " subpage that leaves a standard margin (left-hand margin of eight\n"
22030 " character heights, and a margin around the other three sides of five\n"
22031 " character heights).\n"
22032 "\n"
22033 " Redacted form: plvasp(aspect)\n"
22034 "\n"
22035 " This function is used in example 13.\n"
22036 "\n"
22037 "\n"
22038 "\n"
22039 "SYNOPSIS:\n"
22040 "\n"
22041 "plvasp(aspect)\n"
22042 "\n"
22043 "ARGUMENTS:\n"
22044 "\n"
22045 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22046 " axis of resulting viewport.\n"
22047 "\n"
22048 ""},
22049 { "plvect", _wrap_plvect, METH_VARARGS, "\n"
22050 "Vector plot\n"
22051 "\n"
22052 "DESCRIPTION:\n"
22053 "\n"
22054 " Draws a plot of vector data contained in the matrices (\n"
22055 " u[\n"
22056 " nx][\n"
22057 " ny],\n"
22058 " v[\n"
22059 " nx][\n"
22060 " ny]) . The scaling factor for the vectors is given by scale. A\n"
22061 " transformation routine pointed to by pltr with a pointer pltr_data for\n"
22062 " additional data required by the transformation routine to map indices\n"
22063 " within the matrices to the world coordinates. The style of the vector\n"
22064 " arrow may be set using plsvect.\n"
22065 "\n"
22066 " Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n"
22067 " discussion) the pltr, pltr_data callback arguments are sometimes\n"
22068 " replaced by a tr vector with 6 elements, or xg and yg array arguments\n"
22069 " with either one or two dimensions.\n"
22070 "\n"
22071 " This function is used in example 22.\n"
22072 "\n"
22073 "\n"
22074 "\n"
22075 "SYNOPSIS:\n"
22076 "\n"
22077 "plvect(u, v, nx, ny, scale, pltr, pltr_data)\n"
22078 "\n"
22079 "ARGUMENTS:\n"
22080 "\n"
22081 " u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n"
22082 " and y components of the vector data to be plotted.\n"
22083 "\n"
22084 " nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n"
22085 "\n"
22086 " scale (PLFLT, input) : Parameter to control the scaling factor of\n"
22087 " the vectors for plotting. If scale = 0 then the scaling factor is\n"
22088 " automatically calculated for the data. If scale < 0 then the\n"
22089 " scaling factor is automatically calculated for the data and then\n"
22090 " multiplied by -\n"
22091 " scale. If scale > 0 then the scaling factor is set to scale.\n"
22092 "\n"
22093 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22094 " defines the transformation between the zero-based indices of the\n"
22095 " matrices u and v and world coordinates.For the C case,\n"
22096 " transformation functions are provided in the PLplot library: pltr0\n"
22097 " for the identity mapping, and pltr1 and pltr2 for arbitrary\n"
22098 " mappings respectively defined by vectors and matrices. In\n"
22099 " addition, C callback routines for the transformation can be\n"
22100 " supplied by the user such as the mypltr function in\n"
22101 " examples/c/x09c.c which provides a general linear transformation\n"
22102 " between index coordinates and world coordinates.For languages\n"
22103 " other than C you should consult the PLplot documentation for the\n"
22104 " details concerning how PLTRANSFORM_callback arguments are\n"
22105 " interfaced. However, in general, a particular pattern of\n"
22106 " callback-associated arguments such as a tr vector with 6 elements;\n"
22107 " xg and yg vectors; or xg and yg matrices are respectively\n"
22108 " interfaced to a linear-transformation routine similar to the above\n"
22109 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22110 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22111 " support native language callbacks for handling index to\n"
22112 " world-coordinate transformations. Examples of these various\n"
22113 " approaches are given in examples/<language>x09*,\n"
22114 " examples/<language>x16*, examples/<language>x20*,\n"
22115 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22116 " supported languages.\n"
22117 "\n"
22118 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22119 " information to pltr0, pltr1, pltr2, or whatever callback routine\n"
22120 " that is externally supplied.\n"
22121 "\n"
22122 ""},
22123 { "plvpas", _wrap_plvpas, METH_VARARGS, "\n"
22124 "Specify viewport using coordinates and aspect ratio\n"
22125 "\n"
22126 "DESCRIPTION:\n"
22127 "\n"
22128 " Device-independent routine for setting up the viewport. The viewport\n"
22129 " is chosen to be the largest with the given aspect ratio that fits\n"
22130 " within the specified region (in terms of normalized subpage\n"
22131 " coordinates). This routine is functionally equivalent to plvpor when\n"
22132 " a ``natural'' aspect ratio (0.0) is chosen. Unlike plvasp, this\n"
22133 " routine reserves no extra space at the edges for labels.\n"
22134 "\n"
22135 " Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22136 "\n"
22137 " This function is used in example 9.\n"
22138 "\n"
22139 "\n"
22140 "\n"
22141 "SYNOPSIS:\n"
22142 "\n"
22143 "plvpas(xmin, xmax, ymin, ymax, aspect)\n"
22144 "\n"
22145 "ARGUMENTS:\n"
22146 "\n"
22147 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22148 " left-hand edge of the viewport.\n"
22149 "\n"
22150 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22151 " right-hand edge of the viewport.\n"
22152 "\n"
22153 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22154 " bottom edge of the viewport.\n"
22155 "\n"
22156 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22157 " edge of the viewport.\n"
22158 "\n"
22159 " aspect (PLFLT, input) : Ratio of length of y axis to length of x\n"
22160 " axis.\n"
22161 "\n"
22162 ""},
22163 { "plvpor", _wrap_plvpor, METH_VARARGS, "\n"
22164 "Specify viewport using normalized subpage coordinates\n"
22165 "\n"
22166 "DESCRIPTION:\n"
22167 "\n"
22168 " Device-independent routine for setting up the viewport. This defines\n"
22169 " the viewport in terms of normalized subpage coordinates which run from\n"
22170 " 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n"
22171 " current subpage. Use the alternate routine plsvpa in order to create\n"
22172 " a viewport of a definite size.\n"
22173 "\n"
22174 " Redacted form: plvpor(xmin, xmax, ymin, ymax)\n"
22175 "\n"
22176 " This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n"
22177 " 24, 26, 27, and 31.\n"
22178 "\n"
22179 "\n"
22180 "\n"
22181 "SYNOPSIS:\n"
22182 "\n"
22183 "plvpor(xmin, xmax, ymin, ymax)\n"
22184 "\n"
22185 "ARGUMENTS:\n"
22186 "\n"
22187 " xmin (PLFLT, input) : The normalized subpage coordinate of the\n"
22188 " left-hand edge of the viewport.\n"
22189 "\n"
22190 " xmax (PLFLT, input) : The normalized subpage coordinate of the\n"
22191 " right-hand edge of the viewport.\n"
22192 "\n"
22193 " ymin (PLFLT, input) : The normalized subpage coordinate of the\n"
22194 " bottom edge of the viewport.\n"
22195 "\n"
22196 " ymax (PLFLT, input) : The normalized subpage coordinate of the top\n"
22197 " edge of the viewport.\n"
22198 "\n"
22199 ""},
22200 { "plvsta", _wrap_plvsta, METH_NOARGS, "\n"
22201 "Select standard viewport\n"
22202 "\n"
22203 "DESCRIPTION:\n"
22204 "\n"
22205 " Selects the largest viewport within the subpage that leaves a standard\n"
22206 " margin (left-hand margin of eight character heights, and a margin\n"
22207 " around the other three sides of five character heights).\n"
22208 "\n"
22209 " Redacted form: plvsta()\n"
22210 "\n"
22211 " This function is used in examples 1, 12, 14, 17, 25, and 29.\n"
22212 "\n"
22213 "\n"
22214 "\n"
22215 "SYNOPSIS:\n"
22216 "\n"
22217 "plvsta()\n"
22218 "\n"
22219 ""},
22220 { "plw3d", _wrap_plw3d, METH_VARARGS, "\n"
22221 "Configure the transformations required for projecting a 3D surface on a 2D window\n"
22222 "\n"
22223 "DESCRIPTION:\n"
22224 "\n"
22225 " Configure the transformations required for projecting a 3D surface on\n"
22226 " an existing 2D window. Those transformations (see the PLplot\n"
22227 " documentation) are done to a rectangular cuboid enclosing the 3D\n"
22228 " surface which has its limits expressed in 3D world coordinates and\n"
22229 " also normalized 3D coordinates (used for interpreting the altitude and\n"
22230 " azimuth of the viewing angle). The transformations consist of the\n"
22231 " linear transform from 3D world coordinates to normalized 3D\n"
22232 " coordinates, and the 3D rotation of normalized coordinates required to\n"
22233 " align the pole of the new 3D coordinate system with the viewing\n"
22234 " direction specified by altitude and azimuth so that x and y of the\n"
22235 " surface elements in that transformed coordinate system are the\n"
22236 " projection of the 3D surface with given viewing direction on the 2D\n"
22237 " window.\n"
22238 "\n"
22239 " The enclosing rectangular cuboid for the surface plot is defined by\n"
22240 " xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n"
22241 " mapped into the same rectangular cuboid with normalized 3D coordinate\n"
22242 " sizes of basex by basey by height so that xmin maps to -\n"
22243 " basex/2, xmax maps to basex/2, ymin maps to -\n"
22244 " basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n"
22245 " The resulting rectangular cuboid in normalized coordinates is then\n"
22246 " viewed by an observer at altitude alt and azimuth az. This routine\n"
22247 " must be called before plbox3 or any of the 3D surface plotting\n"
22248 " routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n"
22249 " plsurf3dl or plfill3.\n"
22250 "\n"
22251 " Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n"
22252 " zmin, zmax, alt, az)\n"
22253 "\n"
22254 " This function is examples 8, 11, 18, and 21.\n"
22255 "\n"
22256 "\n"
22257 "\n"
22258 "SYNOPSIS:\n"
22259 "\n"
22260 "plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n"
22261 "\n"
22262 "ARGUMENTS:\n"
22263 "\n"
22264 " basex (PLFLT, input) : The normalized x coordinate size of the\n"
22265 " rectangular cuboid.\n"
22266 "\n"
22267 " basey (PLFLT, input) : The normalized y coordinate size of the\n"
22268 " rectangular cuboid.\n"
22269 "\n"
22270 " height (PLFLT, input) : The normalized z coordinate size of the\n"
22271 " rectangular cuboid.\n"
22272 "\n"
22273 " xmin (PLFLT, input) : The minimum x world coordinate of the\n"
22274 " rectangular cuboid.\n"
22275 "\n"
22276 " xmax (PLFLT, input) : The maximum x world coordinate of the\n"
22277 " rectangular cuboid.\n"
22278 "\n"
22279 " ymin (PLFLT, input) : The minimum y world coordinate of the\n"
22280 " rectangular cuboid.\n"
22281 "\n"
22282 " ymax (PLFLT, input) : The maximum y world coordinate of the\n"
22283 " rectangular cuboid.\n"
22284 "\n"
22285 " zmin (PLFLT, input) : The minimum z world coordinate of the\n"
22286 " rectangular cuboid.\n"
22287 "\n"
22288 " zmax (PLFLT, input) : The maximum z world coordinate of the\n"
22289 " rectangular cuboid.\n"
22290 "\n"
22291 " alt (PLFLT, input) : The viewing altitude in degrees above the xy\n"
22292 " plane of the rectangular cuboid in normalized coordinates.\n"
22293 "\n"
22294 " az (PLFLT, input) : The viewing azimuth in degrees of the\n"
22295 " rectangular cuboid in normalized coordinates. When az=0, the\n"
22296 " observer is looking face onto the zx plane of the rectangular\n"
22297 " cuboid in normalized coordinates, and as az is increased, the\n"
22298 " observer moves clockwise around that cuboid when viewed from above\n"
22299 " the xy plane.\n"
22300 "\n"
22301 ""},
22302 { "plwidth", _wrap_plwidth, METH_O, "\n"
22303 "Set pen width\n"
22304 "\n"
22305 "DESCRIPTION:\n"
22306 "\n"
22307 " Sets the pen width.\n"
22308 "\n"
22309 " Redacted form: plwidth(width)\n"
22310 "\n"
22311 " This function is used in examples 1 and 2.\n"
22312 "\n"
22313 "\n"
22314 "\n"
22315 "SYNOPSIS:\n"
22316 "\n"
22317 "plwidth(width)\n"
22318 "\n"
22319 "ARGUMENTS:\n"
22320 "\n"
22321 " width (PLFLT, input) : The desired pen width. If width is negative\n"
22322 " or the same as the previous value no action is taken. width = 0.\n"
22323 " should be interpreted as as the minimum valid pen width for the\n"
22324 " device. The interpretation of positive width values is also\n"
22325 " device dependent.\n"
22326 "\n"
22327 ""},
22328 { "plwind", _wrap_plwind, METH_VARARGS, "\n"
22329 "Specify window\n"
22330 "\n"
22331 "DESCRIPTION:\n"
22332 "\n"
22333 " Specify the window, i.e., the world coordinates of the edges of the\n"
22334 " viewport.\n"
22335 "\n"
22336 " Redacted form: plwind(xmin, xmax, ymin, ymax)\n"
22337 "\n"
22338 " This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n"
22339 " 29, and 31.\n"
22340 "\n"
22341 "\n"
22342 "\n"
22343 "SYNOPSIS:\n"
22344 "\n"
22345 "plwind(xmin, xmax, ymin, ymax)\n"
22346 "\n"
22347 "ARGUMENTS:\n"
22348 "\n"
22349 " xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n"
22350 " of the viewport.\n"
22351 "\n"
22352 " xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n"
22353 " of the viewport.\n"
22354 "\n"
22355 " ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n"
22356 " the viewport.\n"
22357 "\n"
22358 " ymax (PLFLT, input) : The world y coordinate of the top edge of the\n"
22359 " viewport.\n"
22360 "\n"
22361 ""},
22362 { "plxormod", _wrap_plxormod, METH_O, "\n"
22363 "Enter or leave xor mode\n"
22364 "\n"
22365 "DESCRIPTION:\n"
22366 "\n"
22367 " Enter (when mode is true) or leave (when mode is false) xor mode for\n"
22368 " those drivers (e.g., the xwin driver) that support it. Enables\n"
22369 " erasing plots by drawing twice the same line, symbol, etc. If driver\n"
22370 " is not capable of xor operation it returns a status of false.\n"
22371 "\n"
22372 " Redacted form: plxormod(mode, status)\n"
22373 "\n"
22374 " This function is used in examples 1 and 20.\n"
22375 "\n"
22376 "\n"
22377 "\n"
22378 "SYNOPSIS:\n"
22379 "\n"
22380 "plxormod(mode, status)\n"
22381 "\n"
22382 "ARGUMENTS:\n"
22383 "\n"
22384 " mode (PLBOOL, input) : mode is true means enter xor mode and mode\n"
22385 " is false means leave xor mode.\n"
22386 "\n"
22387 " status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n"
22388 " modestatus of true (false) means driver is capable (incapable) of\n"
22389 " xor mode.\n"
22390 "\n"
22391 ""},
22392 { "plmap", _wrap_plmap, METH_VARARGS, "\n"
22393 "Plot continental outline or shapefile data in world coordinates\n"
22394 "\n"
22395 "DESCRIPTION:\n"
22396 "\n"
22397 " Plots continental outlines or shapefile data in world coordinates. A\n"
22398 " demonstration of how to use this function to create different\n"
22399 " projections can be found in examples/c/x19c. PLplot is provided with\n"
22400 " basic coastal outlines and USA state borders. To use the map\n"
22401 " functionality PLplot must be compiled with the shapelib library.\n"
22402 " Shapefiles have become a popular standard for geographical data and\n"
22403 " data in this format can be easily found from a number of online\n"
22404 " sources. Shapefile data is actually provided as three or more files\n"
22405 " with the same filename, but different extensions. The .shp and .shx\n"
22406 " files are required for plotting Shapefile data with PLplot.\n"
22407 "\n"
22408 " PLplot currently supports the point, multipoint, polyline and polygon\n"
22409 " objects within shapefiles. However holes in polygons are not\n"
22410 " supported. When plmap is used the type of object is derived from the\n"
22411 " shapefile, if you wish to override the type then use one of the other\n"
22412 " plmap variants. The built in maps have line data only.\n"
22413 "\n"
22414 " Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n"
22415 "\n"
22416 " This function is used in example 19.\n"
22417 "\n"
22418 "\n"
22419 "\n"
22420 "SYNOPSIS:\n"
22421 "\n"
22422 "plmap(mapform, name, minx, maxx, miny, maxy)\n"
22423 "\n"
22424 "ARGUMENTS:\n"
22425 "\n"
22426 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22427 " transform the original map data coordinates to a new coordinate\n"
22428 " system. The PLplot-supplied map data is provided as latitudes and\n"
22429 " longitudes; other Shapefile data may be provided in other\n"
22430 " coordinate systems as can be found in their .prj plain text files.\n"
22431 " For example, by using this transform we can change from a\n"
22432 " longitude, latitude coordinate to a polar stereographic\n"
22433 " projection. Initially, x[0]..[n-1] are the original x coordinates\n"
22434 " (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n"
22435 " corresponding y coordinates (latitudes for the PLplot supplied\n"
22436 " data). After the call to mapform(), x[] and y[] should be\n"
22437 " replaced by the corresponding plot coordinates. If no transform is\n"
22438 " desired, mapform can be replaced by NULL.\n"
22439 "\n"
22440 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22441 " the type of map plotted. This is either one of the PLplot built-in\n"
22442 " maps or the file name of a set of Shapefile files without the file\n"
22443 " extensions. For the PLplot built-in maps the possible values are:\n"
22444 " \"globe\" -- continental outlines\n"
22445 " \"usa\" -- USA and state boundaries\n"
22446 " \"cglobe\" -- continental outlines and countries\n"
22447 " \"usaglobe\" -- USA, state boundaries and continental outlines\n"
22448 "\n"
22449 "\n"
22450 " minx (PLFLT, input) : The minimum x value of map elements to be\n"
22451 " drawn. The units must match the shapefile (built in maps are\n"
22452 " degrees lat/lon). Objects in the file which do not encroach on the\n"
22453 " box defined by minx, maxx, miny, maxy will not be rendered. But\n"
22454 " note this is simply an optimisation, not a clipping so for objects\n"
22455 " with some points inside the box and some points outside the box\n"
22456 " all the points will be rendered. These parameters also define\n"
22457 " latitude and longitude wrapping for shapefiles using these units.\n"
22458 " Longitude points will be wrapped by integer multiples of 360\n"
22459 " degrees to place them in the box. This allows the same data to be\n"
22460 " used on plots from -180-180 or 0-360 longitude ranges. In fact if\n"
22461 " you plot from -180-540 you will get two cycles of data drawn. The\n"
22462 " value of minx must be less than the value of maxx. Passing in a\n"
22463 " nan, max/-max floating point number or +/-infinity will case the\n"
22464 " bounding box from the shapefile to be used.\n"
22465 "\n"
22466 " maxx (PLFLT, input) : The maximum x value of map elements to be\n"
22467 " drawn - see minx.\n"
22468 "\n"
22469 " miny (PLFLT, input) : The minimum y value of map elements to be\n"
22470 " drawn - see minx.\n"
22471 "\n"
22472 " maxy (PLFLT, input) : The maximum y value of map elements to be\n"
22473 " drawn - see minx.\n"
22474 "\n"
22475 ""},
22476 { "plmapline", _wrap_plmapline, METH_VARARGS, "\n"
22477 "Plot all or a subset of Shapefile data using lines in world coordinates\n"
22478 "\n"
22479 "DESCRIPTION:\n"
22480 "\n"
22481 " Plot all or a subset of Shapefile data using lines in world\n"
22482 " coordinates. Our 19th standard example demonstrates how to use this\n"
22483 " function. This function plots data from a Shapefile using lines as in\n"
22484 " plmap, however it also has the option of also only drawing specified\n"
22485 " elements from the Shapefile. The vector of indices of the required\n"
22486 " elements are passed as a function argument. The Shapefile data should\n"
22487 " include a metadata file (extension.dbf) listing all items within the\n"
22488 " Shapefile. This file can be opened by most popular spreadsheet\n"
22489 " programs and can be used to decide which indices to pass to this\n"
22490 " function.\n"
22491 "\n"
22492 " Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n"
22493 " plotentries)\n"
22494 "\n"
22495 " This function is used in example 19.\n"
22496 "\n"
22497 "\n"
22498 "\n"
22499 "SYNOPSIS:\n"
22500 "\n"
22501 "plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22502 "\n"
22503 "ARGUMENTS:\n"
22504 "\n"
22505 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22506 " transform the coordinates given in the shapefile into a plot\n"
22507 " coordinate system. By using this transform, we can change from a\n"
22508 " longitude, latitude coordinate to a polar stereographic project,\n"
22509 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22510 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22511 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22512 " plot coordinates. If no transform is desired, mapform can be\n"
22513 " replaced by NULL.\n"
22514 "\n"
22515 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22516 " the file name of a set of Shapefile files without the file\n"
22517 " extension.\n"
22518 "\n"
22519 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22520 " be in the same units as used by the Shapefile. You could use a\n"
22521 " very large negative number to plot everything, but you can improve\n"
22522 " performance by limiting the area drawn. The units must match those\n"
22523 " of the Shapefile projection, which may be for example longitude or\n"
22524 " distance. The value of minx must be less than the value of maxx.\n"
22525 "\n"
22526 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22527 " use a very large number to plot everything, but you can improve\n"
22528 " performance by limiting the area drawn.\n"
22529 "\n"
22530 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22531 " be in the same units as used by the Shapefile. You could use a\n"
22532 " very large negative number to plot everything, but you can improve\n"
22533 " performance by limiting the area drawn. The units must match those\n"
22534 " of the Shapefile projection, which may be for example latitude or\n"
22535 " distance. The value of miny must be less than the value of maxy.\n"
22536 "\n"
22537 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22538 " use a very large number to plot everything, but you can improve\n"
22539 " performance by limiting the area drawn.\n"
22540 "\n"
22541 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22542 " zero-based indices of the Shapefile elements which will be drawn.\n"
22543 " Setting\n"
22544 " plotentries to NULL will plot all elements of the Shapefile.\n"
22545 "\n"
22546 " nplotentries (PLINT, input) : The number of items in\n"
22547 " plotentries. Ignored if\n"
22548 " plotentries is NULL.\n"
22549 "\n"
22550 ""},
22551 { "plmapstring", _wrap_plmapstring, METH_VARARGS, "\n"
22552 "Plot all or a subset of Shapefile data using strings or points in world coordinates\n"
22553 "\n"
22554 "DESCRIPTION:\n"
22555 "\n"
22556 " As per plmapline, however the items are plotted as strings or points\n"
22557 " in the same way as plstring.\n"
22558 "\n"
22559 " Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n"
22560 " maxy, plotentries)\n"
22561 "\n"
22562 " This function is not used in any examples.\n"
22563 "\n"
22564 "\n"
22565 "\n"
22566 "SYNOPSIS:\n"
22567 "\n"
22568 "plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22569 "\n"
22570 "ARGUMENTS:\n"
22571 "\n"
22572 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22573 " transform the coordinates given in the shapefile into a plot\n"
22574 " coordinate system. By using this transform, we can change from a\n"
22575 " longitude, latitude coordinate to a polar stereographic project,\n"
22576 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22577 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22578 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22579 " plot coordinates. If no transform is desired, mapform can be\n"
22580 " replaced by NULL.\n"
22581 "\n"
22582 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22583 " the file name of a set of Shapefile files without the file\n"
22584 " extension.\n"
22585 "\n"
22586 " string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n"
22587 " drawn.\n"
22588 "\n"
22589 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22590 " be in the same units as used by the Shapefile. You could use a\n"
22591 " very large negative number to plot everything, but you can improve\n"
22592 " performance by limiting the area drawn. The units must match those\n"
22593 " of the Shapefile projection, which may be for example longitude or\n"
22594 " distance. The value of minx must be less than the value of maxx.\n"
22595 "\n"
22596 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22597 " use a very large number to plot everything, but you can improve\n"
22598 " performance by limiting the area drawn.\n"
22599 "\n"
22600 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22601 " be in the same units as used by the Shapefile. You could use a\n"
22602 " very large negative number to plot everything, but you can improve\n"
22603 " performance by limiting the area drawn. The units must match those\n"
22604 " of the Shapefile projection, which may be for example latitude or\n"
22605 " distance. The value of miny must be less than the value of maxy.\n"
22606 "\n"
22607 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22608 " use a very large number to plot everything, but you can improve\n"
22609 " performance by limiting the area drawn.\n"
22610 "\n"
22611 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22612 " zero-based indices of the Shapefile elements which will be drawn.\n"
22613 " Setting\n"
22614 " plotentries to NULL will plot all elements of the Shapefile.\n"
22615 "\n"
22616 " nplotentries (PLINT, input) : The number of items in\n"
22617 " plotentries. Ignored if\n"
22618 " plotentries is NULL.\n"
22619 "\n"
22620 ""},
22621 { "plmaptex", _wrap_plmaptex, METH_VARARGS, "\n"
22622 "Draw text at points defined by Shapefile data in world coordinates\n"
22623 "\n"
22624 "DESCRIPTION:\n"
22625 "\n"
22626 " As per plmapline, however the items are plotted as text in the same\n"
22627 " way as plptex.\n"
22628 "\n"
22629 " Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n"
22630 " miny, maxy, plotentry)\n"
22631 "\n"
22632 " This function is used in example 19.\n"
22633 "\n"
22634 "\n"
22635 "\n"
22636 "SYNOPSIS:\n"
22637 "\n"
22638 "plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n"
22639 "\n"
22640 "ARGUMENTS:\n"
22641 "\n"
22642 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22643 " transform the coordinates given in the shapefile into a plot\n"
22644 " coordinate system. By using this transform, we can change from a\n"
22645 " longitude, latitude coordinate to a polar stereographic project,\n"
22646 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22647 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22648 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22649 " plot coordinates. If no transform is desired, mapform can be\n"
22650 " replaced by NULL.\n"
22651 "\n"
22652 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22653 " the file name of a set of Shapefile files without the file\n"
22654 " extension.\n"
22655 "\n"
22656 " dx (PLFLT, input) : Used to define the slope of the texts which is\n"
22657 " dy/dx.\n"
22658 "\n"
22659 " dy (PLFLT, input) : Used to define the slope of the texts which is\n"
22660 " dy/dx.\n"
22661 "\n"
22662 " just (PLFLT, input) : Set the justification of the text. The value\n"
22663 " given will be the fraction of the distance along the string that\n"
22664 " sits at the given point. 0.0 gives left aligned text, 0.5 gives\n"
22665 " centralized text and 1.0 gives right aligned text.\n"
22666 "\n"
22667 " text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n"
22668 "\n"
22669 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22670 " be in the same units as used by the Shapefile. You could use a\n"
22671 " very large negative number to plot everything, but you can improve\n"
22672 " performance by limiting the area drawn. The units must match those\n"
22673 " of the Shapefile projection, which may be for example longitude or\n"
22674 " distance. The value of minx must be less than the value of maxx.\n"
22675 "\n"
22676 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22677 " use a very large number to plot everything, but you can improve\n"
22678 " performance by limiting the area drawn.\n"
22679 "\n"
22680 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22681 " be in the same units as used by the Shapefile. You could use a\n"
22682 " very large negative number to plot everything, but you can improve\n"
22683 " performance by limiting the area drawn. The units must match those\n"
22684 " of the Shapefile projection, which may be for example latitude or\n"
22685 " distance. The value of miny must be less than the value of maxy.\n"
22686 "\n"
22687 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22688 " use a very large number to plot everything, but you can improve\n"
22689 " performance by limiting the area drawn.\n"
22690 "\n"
22691 " plotentry (PLINT, input) : An integer indicating which text string\n"
22692 " of the Shapefile (zero indexed) will be drawn.\n"
22693 "\n"
22694 ""},
22695 { "plmapfill", _wrap_plmapfill, METH_VARARGS, "\n"
22696 "Plot all or a subset of Shapefile data, filling the polygons\n"
22697 "\n"
22698 "DESCRIPTION:\n"
22699 "\n"
22700 " As per plmapline, however the items are filled in the same way as\n"
22701 " plfill.\n"
22702 "\n"
22703 " Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n"
22704 " plotentries)\n"
22705 "\n"
22706 " This function is used in example 19.\n"
22707 "\n"
22708 "\n"
22709 "\n"
22710 "SYNOPSIS:\n"
22711 "\n"
22712 "plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n"
22713 "\n"
22714 "ARGUMENTS:\n"
22715 "\n"
22716 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22717 " transform the coordinates given in the shapefile into a plot\n"
22718 " coordinate system. By using this transform, we can change from a\n"
22719 " longitude, latitude coordinate to a polar stereographic project,\n"
22720 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22721 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22722 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22723 " plot coordinates. If no transform is desired, mapform can be\n"
22724 " replaced by NULL.\n"
22725 "\n"
22726 " name (PLCHAR_VECTOR, input) : An ascii character string specifying\n"
22727 " the file name of a set of Shapefile files without the file\n"
22728 " extension.\n"
22729 "\n"
22730 " minx (PLFLT, input) : The minimum x value to be plotted. This must\n"
22731 " be in the same units as used by the Shapefile. You could use a\n"
22732 " very large negative number to plot everything, but you can improve\n"
22733 " performance by limiting the area drawn. The units must match those\n"
22734 " of the Shapefile projection, which may be for example longitude or\n"
22735 " distance. The value of minx must be less than the value of maxx.\n"
22736 "\n"
22737 " maxx (PLFLT, input) : The maximum x value to be plotted. You could\n"
22738 " use a very large number to plot everything, but you can improve\n"
22739 " performance by limiting the area drawn.\n"
22740 "\n"
22741 " miny (PLFLT, input) : The minimum y value to be plotted. This must\n"
22742 " be in the same units as used by the Shapefile. You could use a\n"
22743 " very large negative number to plot everything, but you can improve\n"
22744 " performance by limiting the area drawn. The units must match those\n"
22745 " of the Shapefile projection, which may be for example latitude or\n"
22746 " distance. The value of miny must be less than the value of maxy.\n"
22747 "\n"
22748 " maxy (PLFLT, input) : The maximum y value to be plotted. You could\n"
22749 " use a very large number to plot everything, but you can improve\n"
22750 " performance by limiting the area drawn.\n"
22751 "\n"
22752 " plotentries (PLINT_VECTOR, input) : A vector containing the\n"
22753 " zero-based indices of the Shapefile elements which will be drawn.\n"
22754 " Setting\n"
22755 " plotentries to NULL will plot all elements of the Shapefile.\n"
22756 "\n"
22757 " nplotentries (PLINT, input) : The number of items in\n"
22758 " plotentries. Ignored if\n"
22759 " plotentries is NULL.\n"
22760 "\n"
22761 ""},
22762 { "plmeridians", _wrap_plmeridians, METH_VARARGS, "\n"
22763 "Plot latitude and longitude lines\n"
22764 "\n"
22765 "DESCRIPTION:\n"
22766 "\n"
22767 " Displays latitude and longitude on the current plot. The lines are\n"
22768 " plotted in the current color and line style.\n"
22769 "\n"
22770 " Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n"
22771 " minlat, maxlat)\n"
22772 "\n"
22773 " This function is used in example 19.\n"
22774 "\n"
22775 "\n"
22776 "\n"
22777 "SYNOPSIS:\n"
22778 "\n"
22779 "plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n"
22780 "\n"
22781 "ARGUMENTS:\n"
22782 "\n"
22783 " mapform (PLMAPFORM_callback, input) : A user supplied function to\n"
22784 " transform the coordinate longitudes and latitudes to a plot\n"
22785 " coordinate system. By using this transform, we can change from a\n"
22786 " longitude, latitude coordinate to a polar stereographic project,\n"
22787 " for example. Initially, x[0]..[n-1] are the longitudes and\n"
22788 " y[0]..y[n-1] are the corresponding latitudes. After the call to\n"
22789 " mapform(), x[] and y[] should be replaced by the corresponding\n"
22790 " plot coordinates. If no transform is desired, mapform can be\n"
22791 " replaced by NULL.\n"
22792 "\n"
22793 " dlong (PLFLT, input) : The interval in degrees at which the\n"
22794 " longitude lines are to be plotted.\n"
22795 "\n"
22796 " dlat (PLFLT, input) : The interval in degrees at which the latitude\n"
22797 " lines are to be plotted.\n"
22798 "\n"
22799 " minlong (PLFLT, input) : The value of the longitude on the left\n"
22800 " side of the plot. The value of minlong must be less than the value\n"
22801 " of maxlong, and the quantity maxlong-minlong must be less than or\n"
22802 " equal to 360.\n"
22803 "\n"
22804 " maxlong (PLFLT, input) : The value of the longitude on the right\n"
22805 " side of the plot.\n"
22806 "\n"
22807 " minlat (PLFLT, input) : The minimum latitude to be plotted on the\n"
22808 " background. One can always use -90.0 as the boundary outside the\n"
22809 " plot window will be automatically eliminated. However, the\n"
22810 " program will be faster if one can reduce the size of the\n"
22811 " background plotted.\n"
22812 "\n"
22813 " maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n"
22814 " background. One can always use 90.0 as the boundary outside the\n"
22815 " plot window will be automatically eliminated.\n"
22816 "\n"
22817 ""},
22818 { "plimage", _wrap_plimage, METH_VARARGS, "\n"
22819 "Plot a 2D matrix using cmap1 with automatic color adjustment\n"
22820 "\n"
22821 "DESCRIPTION:\n"
22822 "\n"
22823 " Plot a 2D matrix using the cmap1 palette. The color scale is\n"
22824 " automatically adjusted to use the maximum and minimum values in idata\n"
22825 " as valuemin and valuemax in a call to plimagefr.\n"
22826 "\n"
22827 " Redacted form: General: plimage(idata, xmin, xmax, ymin, ymax, zmin,\n"
22828 " zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22829 "\n"
22830 "\n"
22831 " This function is used in example 20.\n"
22832 "\n"
22833 "\n"
22834 "\n"
22835 "SYNOPSIS:\n"
22836 "\n"
22837 "plimage(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax, Dymin, Dymax)\n"
22838 "\n"
22839 "ARGUMENTS:\n"
22840 "\n"
22841 " idata (PLFLT_MATRIX, input) : A matrix containing function values\n"
22842 " to plot. Should have dimensions of\n"
22843 " nx by\n"
22844 " ny.\n"
22845 "\n"
22846 " nx, ny (PLINT, input) : Dimensions of idata\n"
22847 "\n"
22848 " xmin, xmax, ymin, ymax (PLFLT, input) : The x and y index ranges\n"
22849 " are linearly transformed to these world coordinate ranges such\n"
22850 " that idata[0][0] corresponds to (xmin, ymin) and idata[nx - 1][ny\n"
22851 " - 1] corresponds to (xmax, ymax).\n"
22852 "\n"
22853 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22854 " (inclusive) will be plotted.\n"
22855 "\n"
22856 " Dxmin, Dxmax, Dymin, Dymax (PLFLT, input) : Plot only the window of\n"
22857 " points whose plot coordinates fall inside the window of (Dxmin,\n"
22858 " Dymin) to (Dxmax, Dymax).\n"
22859 "\n"
22860 ""},
22861 { "plimagefr", _wrap_plimagefr, METH_VARARGS, "\n"
22862 "Plot a 2D matrix using cmap1\n"
22863 "\n"
22864 "DESCRIPTION:\n"
22865 "\n"
22866 " Plot a 2D matrix using cmap1.\n"
22867 "\n"
22868 " Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n"
22869 " zmax, valuemin, valuemax, pltr, pltr_data)\n"
22870 "\n"
22871 "\n"
22872 " This function is used in example 20.\n"
22873 "\n"
22874 "\n"
22875 "\n"
22876 "SYNOPSIS:\n"
22877 "\n"
22878 "plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n"
22879 "\n"
22880 "ARGUMENTS:\n"
22881 "\n"
22882 " idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n"
22883 " plot. Should have dimensions of\n"
22884 " nx by\n"
22885 " ny.\n"
22886 "\n"
22887 " nx, ny (PLINT, input) : Dimensions of idata\n"
22888 "\n"
22889 " xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n"
22890 " pltr below for how these arguments are used (only for the special case\n"
22891 " when the callback function\n"
22892 " pltr is not supplied).\n"
22893 "\n"
22894 " zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n"
22895 " (inclusive) will be plotted.\n"
22896 "\n"
22897 " valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n"
22898 " values to use for value to color mappings. A datum equal to or\n"
22899 " less than valuemin will be plotted with color 0.0, while a datum\n"
22900 " equal to or greater than valuemax will be plotted with color 1.0.\n"
22901 " Data between valuemin and valuemax map linearly to colors in the\n"
22902 " range (0.0-1.0).\n"
22903 "\n"
22904 " pltr (PLTRANSFORM_callback, input) : A callback function that\n"
22905 " defines the transformation between the zero-based indices of the\n"
22906 " matrix idata and world coordinates. If\n"
22907 " pltr is not supplied (e.g., is set to NULL in the C case), then the x\n"
22908 " indices of idata are mapped to the range\n"
22909 " xmin through\n"
22910 " xmax and the y indices of idata are mapped to the range\n"
22911 " ymin through\n"
22912 " ymax.For the C case, transformation functions are provided in the\n"
22913 " PLplot library: pltr0 for the identity mapping, and pltr1 and\n"
22914 " pltr2 for arbitrary mappings respectively defined by vectors and\n"
22915 " matrices. In addition, C callback routines for the transformation\n"
22916 " can be supplied by the user such as the mypltr function in\n"
22917 " examples/c/x09c.c which provides a general linear transformation\n"
22918 " between index coordinates and world coordinates.For languages\n"
22919 " other than C you should consult the PLplot documentation for the\n"
22920 " details concerning how PLTRANSFORM_callback arguments are\n"
22921 " interfaced. However, in general, a particular pattern of\n"
22922 " callback-associated arguments such as a tr vector with 6 elements;\n"
22923 " xg and yg vectors; or xg and yg matrices are respectively\n"
22924 " interfaced to a linear-transformation routine similar to the above\n"
22925 " mypltr function; pltr1; and pltr2. Furthermore, some of our more\n"
22926 " sophisticated bindings (see, e.g., the PLplot documentation)\n"
22927 " support native language callbacks for handling index to\n"
22928 " world-coordinate transformations. Examples of these various\n"
22929 " approaches are given in examples/<language>x09*,\n"
22930 " examples/<language>x16*, examples/<language>x20*,\n"
22931 " examples/<language>x21*, and examples/<language>x22*, for all our\n"
22932 " supported languages.\n"
22933 "\n"
22934 " pltr_data (PLPointer, input) : Extra parameter to help pass\n"
22935 " information to pltr0, pltr1, pltr2, or whatever routine is\n"
22936 " externally supplied.\n"
22937 "\n"
22938 ""},
22939 { "plClearOpts", _wrap_plClearOpts, METH_NOARGS, NULL},
22940 { "plResetOpts", _wrap_plResetOpts, METH_NOARGS, NULL},
22941 { "plSetUsage", _wrap_plSetUsage, METH_VARARGS, NULL},
22942 { "plOptUsage", _wrap_plOptUsage, METH_NOARGS, NULL},
22943 { "plMinMax2dGrid", _wrap_plMinMax2dGrid, METH_O, NULL},
22944 { "plGetCursor", _wrap_plGetCursor, METH_O, "\n"
22945 "Wait for graphics input event and translate to world coordinates.\n"
22946 "\n"
22947 "DESCRIPTION:\n"
22948 "\n"
22949 " Wait for graphics input event and translate to world coordinates.\n"
22950 " Returns 0 if no translation to world coordinates is possible.\n"
22951 "\n"
22952 " This function returns 1 on success and 0 if no translation to world\n"
22953 " coordinates is possible.\n"
22954 "\n"
22955 " Redacted form: plGetCursor(gin)\n"
22956 "\n"
22957 " This function is used in examples 1 and 20.\n"
22958 "\n"
22959 "\n"
22960 "\n"
22961 "SYNOPSIS:\n"
22962 "\n"
22963 "PLINT plGetCursor(gin)\n"
22964 "\n"
22965 "ARGUMENTS:\n"
22966 "\n"
22967 " gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n"
22968 " which will contain the output. The structure is not allocated by\n"
22969 " the routine and must exist before the function is called.\n"
22970 "\n"
22971 ""},
22972 { NULL, NULL, 0, NULL }
22973};
22974
22975
22976/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
22977
22978static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)0, 0};
22979static swig_type_info _swigt__p_PLcGrid = {"_p_PLcGrid", "PLcGrid *", 0, 0, (void*)0, 0};
22980static swig_type_info _swigt__p_PLcGrid2 = {"_p_PLcGrid2", "PLcGrid2 *", 0, 0, (void*)0, 0};
22981static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
22982static swig_type_info _swigt__p_double = {"_p_double", "PLFLT *|double *", 0, 0, (void*)0, 0};
22983static swig_type_info _swigt__p_f_double_double__int = {"_p_f_double_double__int", "defined_func|int (*)(double,double)", 0, 0, (void*)0, 0};
22984static 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};
22985static 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};
22986static 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};
22987static 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};
22988static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|PLINT *|int *", 0, 0, (void*)0, 0};
22989static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
22990static swig_type_info _swigt__p_p_double = {"_p_p_double", "PLFLT **|double **", 0, 0, (void*)0, 0};
22991static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "PLUNICODE *|unsigned int *", 0, 0, (void*)0, 0};
22992
23009
23010static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
23011static swig_cast_info _swigc__p_PLcGrid[] = { {&_swigt__p_PLcGrid, 0, 0, 0},{0, 0, 0, 0}};
23012static swig_cast_info _swigc__p_PLcGrid2[] = { {&_swigt__p_PLcGrid2, 0, 0, 0},{0, 0, 0, 0}};
23013static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
23014static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
23020static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
23021static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
23022static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
23023static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
23024
23041
23042
23043/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
23044
23046{0, 0, 0, 0.0, 0, 0}};
23047
23048#ifdef __cplusplus
23049}
23050#endif
23051/* -----------------------------------------------------------------------------
23052 * Type initialization:
23053 * This problem is tough by the requirement that no dynamic
23054 * memory is used. Also, since swig_type_info structures store pointers to
23055 * swig_cast_info structures and swig_cast_info structures store pointers back
23056 * to swig_type_info structures, we need some lookup code at initialization.
23057 * The idea is that swig generates all the structures that are needed.
23058 * The runtime then collects these partially filled structures.
23059 * The SWIG_InitializeModule function takes these initial arrays out of
23060 * swig_module, and does all the lookup, filling in the swig_module.types
23061 * array with the correct data and linking the correct swig_cast_info
23062 * structures together.
23063 *
23064 * The generated swig_type_info structures are assigned statically to an initial
23065 * array. We just loop through that array, and handle each type individually.
23066 * First we lookup if this type has been already loaded, and if so, use the
23067 * loaded structure instead of the generated one. Then we have to fill in the
23068 * cast linked list. The cast data is initially stored in something like a
23069 * two-dimensional array. Each row corresponds to a type (there are the same
23070 * number of rows as there are in the swig_type_initial array). Each entry in
23071 * a column is one of the swig_cast_info structures for that type.
23072 * The cast_initial array is actually an array of arrays, because each row has
23073 * a variable number of columns. So to actually build the cast linked list,
23074 * we find the array of casts associated with the type, and loop through it
23075 * adding the casts to the list. The one last trick we need to do is making
23076 * sure the type pointer in the swig_cast_info struct is correct.
23077 *
23078 * First off, we lookup the cast->type name to see if it is already loaded.
23079 * There are three cases to handle:
23080 * 1) If the cast->type has already been loaded AND the type we are adding
23081 * casting info to has not been loaded (it is in this module), THEN we
23082 * replace the cast->type pointer with the type pointer that has already
23083 * been loaded.
23084 * 2) If BOTH types (the one we are adding casting info to, and the
23085 * cast->type) are loaded, THEN the cast info has already been loaded by
23086 * the previous module so we just ignore it.
23087 * 3) Finally, if cast->type has not already been loaded, then we add that
23088 * swig_cast_info to the linked list (because the cast->type) pointer will
23089 * be correct.
23090 * ----------------------------------------------------------------------------- */
23091
23092#ifdef __cplusplus
23093extern "C" {
23094#if 0
23095} /* c-mode */
23096#endif
23097#endif
23098
23099#if 0
23100#define SWIGRUNTIME_DEBUG
23101#endif
23102
23103#ifndef SWIG_INIT_CLIENT_DATA_TYPE
23104#define SWIG_INIT_CLIENT_DATA_TYPE void *
23105#endif
23106
23107SWIGRUNTIME void
23109 size_t i;
23110 swig_module_info *module_head, *iter;
23111 int init;
23112
23113 /* check to see if the circular list has been setup, if not, set it up */
23114 if (swig_module.next==0) {
23115 /* Initialize the swig_module */
23119 init = 1;
23120 } else {
23121 init = 0;
23122 }
23123
23124 /* Try and load any already created modules */
23125 module_head = SWIG_GetModule(clientdata);
23126 if (!module_head) {
23127 /* This is the first module loaded for this interpreter */
23128 /* so set the swig module into the interpreter */
23129 SWIG_SetModule(clientdata, &swig_module);
23130 } else {
23131 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
23132 iter=module_head;
23133 do {
23134 if (iter==&swig_module) {
23135 /* Our module is already in the list, so there's nothing more to do. */
23136 return;
23137 }
23138 iter=iter->next;
23139 } while (iter!= module_head);
23140
23141 /* otherwise we must add our module into the list */
23142 swig_module.next = module_head->next;
23143 module_head->next = &swig_module;
23144 }
23145
23146 /* When multiple interpreters are used, a module could have already been initialized in
23147 a different interpreter, but not yet have a pointer in this interpreter.
23148 In this case, we do not want to continue adding types... everything should be
23149 set up already */
23150 if (init == 0) return;
23151
23152 /* Now work on filling in swig_module.types */
23153#ifdef SWIGRUNTIME_DEBUG
23154 printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
23155#endif
23156 for (i = 0; i < swig_module.size; ++i) {
23157 swig_type_info *type = 0;
23158 swig_type_info *ret;
23159 swig_cast_info *cast;
23160
23161#ifdef SWIGRUNTIME_DEBUG
23162 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23163#endif
23164
23165 /* if there is another module already loaded */
23166 if (swig_module.next != &swig_module) {
23168 }
23169 if (type) {
23170 /* Overwrite clientdata field */
23171#ifdef SWIGRUNTIME_DEBUG
23172 printf("SWIG_InitializeModule: found type %s\n", type->name);
23173#endif
23175 type->clientdata = swig_module.type_initial[i]->clientdata;
23176#ifdef SWIGRUNTIME_DEBUG
23177 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
23178#endif
23179 }
23180 } else {
23181 type = swig_module.type_initial[i];
23182 }
23183
23184 /* Insert casting types */
23185 cast = swig_module.cast_initial[i];
23186 while (cast->type) {
23187 /* Don't need to add information already in the list */
23188 ret = 0;
23189#ifdef SWIGRUNTIME_DEBUG
23190 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
23191#endif
23192 if (swig_module.next != &swig_module) {
23194#ifdef SWIGRUNTIME_DEBUG
23195 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
23196#endif
23197 }
23198 if (ret) {
23199 if (type == swig_module.type_initial[i]) {
23200#ifdef SWIGRUNTIME_DEBUG
23201 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
23202#endif
23203 cast->type = ret;
23204 ret = 0;
23205 } else {
23206 /* Check for casting already in the list */
23207 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
23208#ifdef SWIGRUNTIME_DEBUG
23209 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
23210#endif
23211 if (!ocast) ret = 0;
23212 }
23213 }
23214
23215 if (!ret) {
23216#ifdef SWIGRUNTIME_DEBUG
23217 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
23218#endif
23219 if (type->cast) {
23220 type->cast->prev = cast;
23221 cast->next = type->cast;
23222 }
23223 type->cast = cast;
23224 }
23225 cast++;
23226 }
23227 /* Set entry in modules->types array equal to the type */
23228 swig_module.types[i] = type;
23229 }
23230 swig_module.types[i] = 0;
23231
23232#ifdef SWIGRUNTIME_DEBUG
23233 printf("**** SWIG_InitializeModule: Cast List ******\n");
23234 for (i = 0; i < swig_module.size; ++i) {
23235 int j = 0;
23237 printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
23238 while (cast->type) {
23239 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
23240 cast++;
23241 ++j;
23242 }
23243 printf("---- Total casts: %d\n",j);
23244 }
23245 printf("**** SWIG_InitializeModule: Cast List ******\n");
23246#endif
23247}
23248
23249/* This function will propagate the clientdata field of type to
23250* any new swig_type_info structures that have been added into the list
23251* of equivalent types. It is like calling
23252* SWIG_TypeClientData(type, clientdata) a second time.
23253*/
23254SWIGRUNTIME void
23256 size_t i;
23257 swig_cast_info *equiv;
23258 static int init_run = 0;
23259
23260 if (init_run) return;
23261 init_run = 1;
23262
23263 for (i = 0; i < swig_module.size; i++) {
23264 if (swig_module.types[i]->clientdata) {
23265 equiv = swig_module.types[i]->cast;
23266 while (equiv) {
23267 if (!equiv->converter) {
23268 if (equiv->type && !equiv->type->clientdata)
23270 }
23271 equiv = equiv->next;
23272 }
23273 }
23274 }
23275}
23276
23277#ifdef __cplusplus
23278#if 0
23279{
23280 /* c-mode */
23281#endif
23282}
23283#endif
23284
23285
23286
23287#ifdef __cplusplus
23288extern "C" {
23289#endif
23290
23291 /* -----------------------------------------------------------------------------
23292 * constants/methods manipulation
23293 * ----------------------------------------------------------------------------- */
23294
23295 /* Install Constants */
23296 SWIGINTERN void
23298 PyObject *obj = 0;
23299 size_t i;
23300 for (i = 0; constants[i].type; ++i) {
23301 switch(constants[i].type) {
23302 case SWIG_PY_POINTER:
23303 obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
23304 break;
23305 case SWIG_PY_BINARY:
23306 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
23307 break;
23308 default:
23309 obj = 0;
23310 break;
23311 }
23312 if (obj) {
23313 PyDict_SetItemString(d, constants[i].name, obj);
23314 SWIG_Py_DECREF(obj);
23315 }
23316 }
23317 }
23318
23319 /* -----------------------------------------------------------------------------
23320 * Patch %callback methods' docstrings to hold the callback ptrs
23321 * -----------------------------------------------------------------------------*/
23322
23323 SWIGINTERN void
23324 SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
23325 size_t i;
23326 for (i = 0; methods[i].ml_name; ++i) {
23327 const char *c = methods[i].ml_doc;
23328 if (!c) continue;
23329 c = strstr(c, "swig_ptr: ");
23330 if (c) {
23331 int j;
23332 const swig_const_info *ci = 0;
23333 const char *name = c + 10;
23334 for (j = 0; const_table[j].type; ++j) {
23335 if (strncmp(const_table[j].name, name,
23336 strlen(const_table[j].name)) == 0) {
23337 ci = &(const_table[j]);
23338 break;
23339 }
23340 }
23341 if (ci) {
23342 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
23343 if (ptr) {
23344 size_t shift = (ci->ptype) - types;
23345 swig_type_info *ty = types_initial[shift];
23346 size_t ldoc = (c - methods[i].ml_doc);
23347 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
23348 char *ndoc = (char*)malloc(ldoc + lptr + 10);
23349 if (ndoc) {
23350 char *buff = ndoc;
23351 memcpy(buff, methods[i].ml_doc, ldoc);
23352 buff += ldoc;
23353 memcpy(buff, "swig_ptr: ", 10);
23354 buff += 10;
23355 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
23356 methods[i].ml_doc = ndoc;
23357 }
23358 }
23359 }
23360 }
23361 }
23362 }
23363
23364#ifdef __cplusplus
23365}
23366#endif
23367
23368
23369
23370
23371/* -----------------------------------------------------------------------------*
23372 * Partial Init method
23373 * -----------------------------------------------------------------------------*/
23374
23375#ifdef __cplusplus
23376extern "C"
23377#endif
23378
23380#if PY_VERSION_HEX >= 0x03000000
23381PyObject*
23382#else
23383void
23384#endif
23386 PyObject *m, *d, *md, *globals;
23387
23388#if PY_VERSION_HEX >= 0x03000000
23389 static struct PyModuleDef SWIG_module = {
23390 PyModuleDef_HEAD_INIT,
23391 SWIG_name,
23392 NULL,
23393 -1,
23395 NULL,
23396 NULL,
23397 NULL,
23398 NULL
23399 };
23400#endif
23401
23402#if defined(SWIGPYTHON_BUILTIN)
23403 static SwigPyClientData SwigPyObject_clientdata = {
23404 0, 0, 0, 0, 0, 0, 0
23405 };
23406 static PyGetSetDef this_getset_def = {
23407 (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
23408 };
23409 static SwigPyGetSet thisown_getset_closure = {
23412 };
23413 static PyGetSetDef thisown_getset_def = {
23414 (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
23415 };
23416 PyTypeObject *builtin_pytype;
23417 int builtin_base_count;
23418 swig_type_info *builtin_basetype;
23419 PyObject *tuple;
23420 PyGetSetDescrObject *static_getset;
23421 PyTypeObject *metatype;
23422 PyTypeObject *swigpyobject;
23423 SwigPyClientData *cd;
23424 PyObject *public_interface, *public_symbol;
23425 PyObject *this_descr;
23426 PyObject *thisown_descr;
23427 PyObject *self = 0;
23428 int i;
23429
23430 (void)builtin_pytype;
23431 (void)builtin_base_count;
23432 (void)builtin_basetype;
23433 (void)tuple;
23434 (void)static_getset;
23435 (void)self;
23436
23437 /* Metaclass is used to implement static member variables */
23438 metatype = SwigPyObjectType();
23439 assert(metatype);
23440#endif
23441
23442 (void)globals;
23443
23444 /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
23445 SWIG_This();
23448#ifndef SWIGPYTHON_BUILTIN
23450#endif
23451
23452 /* Fix SwigMethods to carry the callback ptrs when needed */
23454
23455#if PY_VERSION_HEX >= 0x03000000
23456 m = PyModule_Create(&SWIG_module);
23457#else
23458 m = Py_InitModule(SWIG_name, SwigMethods);
23459#endif
23460
23461 md = d = PyModule_GetDict(m);
23462 (void)md;
23463
23465
23466#ifdef SWIGPYTHON_BUILTIN
23467 swigpyobject = SwigPyObject_TypeOnce();
23468
23469 SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
23470 assert(SwigPyObject_stype);
23471 cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
23472 if (!cd) {
23473 SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
23474 SwigPyObject_clientdata.pytype = swigpyobject;
23475 } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
23476 PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
23477# if PY_VERSION_HEX >= 0x03000000
23478 return NULL;
23479# else
23480 return;
23481# endif
23482 }
23483
23484 /* All objects have a 'this' attribute */
23485 this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
23486 (void)this_descr;
23487
23488 /* All objects have a 'thisown' attribute */
23489 thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
23490 (void)thisown_descr;
23491
23492 public_interface = PyList_New(0);
23493 public_symbol = 0;
23494 (void)public_symbol;
23495
23496 PyDict_SetItemString(md, "__all__", public_interface);
23497 SWIG_Py_DECREF(public_interface);
23498 for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
23499 SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
23500 for (i = 0; swig_const_table[i].name != 0; ++i)
23501 SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
23502#endif
23503
23505
23506
23507 import_array();
23508
23509 SWIG_Python_SetConstant(d, "PLESC_SET_RGB",SWIG_From_int((int)(1)));
23510 SWIG_Python_SetConstant(d, "PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
23511 SWIG_Python_SetConstant(d, "PLESC_SET_LPB",SWIG_From_int((int)(3)));
23512 SWIG_Python_SetConstant(d, "PLESC_EXPOSE",SWIG_From_int((int)(4)));
23513 SWIG_Python_SetConstant(d, "PLESC_RESIZE",SWIG_From_int((int)(5)));
23514 SWIG_Python_SetConstant(d, "PLESC_REDRAW",SWIG_From_int((int)(6)));
23515 SWIG_Python_SetConstant(d, "PLESC_TEXT",SWIG_From_int((int)(7)));
23516 SWIG_Python_SetConstant(d, "PLESC_GRAPH",SWIG_From_int((int)(8)));
23517 SWIG_Python_SetConstant(d, "PLESC_FILL",SWIG_From_int((int)(9)));
23518 SWIG_Python_SetConstant(d, "PLESC_DI",SWIG_From_int((int)(10)));
23519 SWIG_Python_SetConstant(d, "PLESC_FLUSH",SWIG_From_int((int)(11)));
23520 SWIG_Python_SetConstant(d, "PLESC_EH",SWIG_From_int((int)(12)));
23521 SWIG_Python_SetConstant(d, "PLESC_GETC",SWIG_From_int((int)(13)));
23522 SWIG_Python_SetConstant(d, "PLESC_SWIN",SWIG_From_int((int)(14)));
23523 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
23524 SWIG_Python_SetConstant(d, "PLESC_XORMOD",SWIG_From_int((int)(16)));
23525 SWIG_Python_SetConstant(d, "PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
23526 SWIG_Python_SetConstant(d, "PLESC_CLEAR",SWIG_From_int((int)(18)));
23527 SWIG_Python_SetConstant(d, "PLESC_DASH",SWIG_From_int((int)(19)));
23528 SWIG_Python_SetConstant(d, "PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
23529 SWIG_Python_SetConstant(d, "PLESC_IMAGE",SWIG_From_int((int)(21)));
23530 SWIG_Python_SetConstant(d, "PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
23531 SWIG_Python_SetConstant(d, "PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
23532 SWIG_Python_SetConstant(d, "PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
23533 SWIG_Python_SetConstant(d, "PLESC_SETBGFG",SWIG_From_int((int)(25)));
23534 SWIG_Python_SetConstant(d, "PLESC_DEVINIT",SWIG_From_int((int)(26)));
23535 SWIG_Python_SetConstant(d, "PLESC_GETBACKEND",SWIG_From_int((int)(27)));
23536 SWIG_Python_SetConstant(d, "PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
23537 SWIG_Python_SetConstant(d, "PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
23538 SWIG_Python_SetConstant(d, "PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
23539 SWIG_Python_SetConstant(d, "PLESC_END_TEXT",SWIG_From_int((int)(31)));
23540 SWIG_Python_SetConstant(d, "PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
23541 SWIG_Python_SetConstant(d, "PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
23542 SWIG_Python_SetConstant(d, "PLESC_ARC",SWIG_From_int((int)(34)));
23543 SWIG_Python_SetConstant(d, "PLESC_GRADIENT",SWIG_From_int((int)(35)));
23544 SWIG_Python_SetConstant(d, "PLESC_MODESET",SWIG_From_int((int)(36)));
23545 SWIG_Python_SetConstant(d, "PLESC_MODEGET",SWIG_From_int((int)(37)));
23546 SWIG_Python_SetConstant(d, "PLESC_FIXASPECT",SWIG_From_int((int)(38)));
23547 SWIG_Python_SetConstant(d, "PLESC_IMPORT_BUFFER",SWIG_From_int((int)(39)));
23548 SWIG_Python_SetConstant(d, "PLESC_APPEND_BUFFER",SWIG_From_int((int)(40)));
23549 SWIG_Python_SetConstant(d, "PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int((int)(41)));
23550 SWIG_Python_SetConstant(d, "PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
23551 SWIG_Python_SetConstant(d, "PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
23552 SWIG_Python_SetConstant(d, "PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
23553 SWIG_Python_SetConstant(d, "PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
23554 SWIG_Python_SetConstant(d, "PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
23555 SWIG_Python_SetConstant(d, "PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
23556 SWIG_Python_SetConstant(d, "ZEROW2B",SWIG_From_int((int)(1)));
23557 SWIG_Python_SetConstant(d, "ZEROW2D",SWIG_From_int((int)(2)));
23558 SWIG_Python_SetConstant(d, "ONEW2B",SWIG_From_int((int)(3)));
23559 SWIG_Python_SetConstant(d, "ONEW2D",SWIG_From_int((int)(4)));
23560 SWIG_Python_SetConstant(d, "PLSWIN_DEVICE",SWIG_From_int((int)(1)));
23561 SWIG_Python_SetConstant(d, "PLSWIN_WORLD",SWIG_From_int((int)(2)));
23562 SWIG_Python_SetConstant(d, "PL_X_AXIS",SWIG_From_int((int)(1)));
23563 SWIG_Python_SetConstant(d, "PL_Y_AXIS",SWIG_From_int((int)(2)));
23564 SWIG_Python_SetConstant(d, "PL_Z_AXIS",SWIG_From_int((int)(3)));
23565 SWIG_Python_SetConstant(d, "PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
23566 SWIG_Python_SetConstant(d, "PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
23567 SWIG_Python_SetConstant(d, "PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
23568 SWIG_Python_SetConstant(d, "PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
23569 SWIG_Python_SetConstant(d, "PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
23570 SWIG_Python_SetConstant(d, "PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
23571 SWIG_Python_SetConstant(d, "PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
23572 SWIG_Python_SetConstant(d, "PL_OPT_INT",SWIG_From_int((int)(0x0400)));
23573 SWIG_Python_SetConstant(d, "PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
23574 SWIG_Python_SetConstant(d, "PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
23575 SWIG_Python_SetConstant(d, "PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
23576 SWIG_Python_SetConstant(d, "PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
23577 SWIG_Python_SetConstant(d, "PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
23578 SWIG_Python_SetConstant(d, "PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
23579 SWIG_Python_SetConstant(d, "PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
23580 SWIG_Python_SetConstant(d, "PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
23581 SWIG_Python_SetConstant(d, "PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
23582 SWIG_Python_SetConstant(d, "PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
23583 SWIG_Python_SetConstant(d, "PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
23584 SWIG_Python_SetConstant(d, "PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
23585 SWIG_Python_SetConstant(d, "PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
23586 SWIG_Python_SetConstant(d, "PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
23587 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
23588 SWIG_Python_SetConstant(d, "PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
23589 SWIG_Python_SetConstant(d, "PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
23590 SWIG_Python_SetConstant(d, "PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
23591 SWIG_Python_SetConstant(d, "PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
23592 SWIG_Python_SetConstant(d, "PL_FCI_SANS",SWIG_From_int((int)(0x0)));
23593 SWIG_Python_SetConstant(d, "PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
23594 SWIG_Python_SetConstant(d, "PL_FCI_MONO",SWIG_From_int((int)(0x2)));
23595 SWIG_Python_SetConstant(d, "PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
23596 SWIG_Python_SetConstant(d, "PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
23597 SWIG_Python_SetConstant(d, "PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
23598 SWIG_Python_SetConstant(d, "PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
23599 SWIG_Python_SetConstant(d, "PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
23600 SWIG_Python_SetConstant(d, "PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
23601 SWIG_Python_SetConstant(d, "PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
23602 SWIG_Python_SetConstant(d, "PL_MAXKEY",SWIG_From_int((int)(16)));
23603 SWIG_Python_SetConstant(d, "PL_MASK_SHIFT",SWIG_From_int((int)(0x1)));
23604 SWIG_Python_SetConstant(d, "PL_MASK_CAPS",SWIG_From_int((int)(0x2)));
23605 SWIG_Python_SetConstant(d, "PL_MASK_CONTROL",SWIG_From_int((int)(0x4)));
23606 SWIG_Python_SetConstant(d, "PL_MASK_ALT",SWIG_From_int((int)(0x8)));
23607 SWIG_Python_SetConstant(d, "PL_MASK_NUM",SWIG_From_int((int)(0x10)));
23608 SWIG_Python_SetConstant(d, "PL_MASK_ALTGR",SWIG_From_int((int)(0x20)));
23609 SWIG_Python_SetConstant(d, "PL_MASK_WIN",SWIG_From_int((int)(0x40)));
23610 SWIG_Python_SetConstant(d, "PL_MASK_SCROLL",SWIG_From_int((int)(0x80)));
23611 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON1",SWIG_From_int((int)(0x100)));
23612 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON2",SWIG_From_int((int)(0x200)));
23613 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON3",SWIG_From_int((int)(0x400)));
23614 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON4",SWIG_From_int((int)(0x800)));
23615 SWIG_Python_SetConstant(d, "PL_MASK_BUTTON5",SWIG_From_int((int)(0x1000)));
23616 SWIG_Python_SetConstant(d, "PL_MAXWINDOWS",SWIG_From_int((int)(64)));
23617 SWIG_Python_SetConstant(d, "PL_NOTSET",SWIG_From_int((int)((-42))));
23618 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL0",SWIG_From_int((int)(16)));
23619 SWIG_Python_SetConstant(d, "PL_DEFAULT_NCOL1",SWIG_From_int((int)(128)));
23620 SWIG_Python_SetConstant(d, "MIN_PLINT_RGB",SWIG_From_int((int)(0)));
23621 SWIG_Python_SetConstant(d, "MAX_PLINT_RGB",SWIG_From_int((int)(255)));
23622 SWIG_Python_SetConstant(d, "MIN_PLFLT_CMAP1",SWIG_From_double((double)(0.)));
23623 SWIG_Python_SetConstant(d, "MAX_PLFLT_CMAP1",SWIG_From_double((double)(1.)));
23624 SWIG_Python_SetConstant(d, "MIN_PLFLT_ALPHA",SWIG_From_double((double)(0.)));
23625 SWIG_Python_SetConstant(d, "MAX_PLFLT_ALPHA",SWIG_From_double((double)(1.)));
23626 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
23627 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
23628 SWIG_Python_SetConstant(d, "PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
23629 SWIG_Python_SetConstant(d, "PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
23630 SWIG_Python_SetConstant(d, "PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
23631 SWIG_Python_SetConstant(d, "PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
23632 SWIG_Python_SetConstant(d, "PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
23633 SWIG_Python_SetConstant(d, "GRID_CSA",SWIG_From_int((int)(1)));
23634 SWIG_Python_SetConstant(d, "GRID_DTLI",SWIG_From_int((int)(2)));
23635 SWIG_Python_SetConstant(d, "GRID_NNI",SWIG_From_int((int)(3)));
23636 SWIG_Python_SetConstant(d, "GRID_NNIDW",SWIG_From_int((int)(4)));
23637 SWIG_Python_SetConstant(d, "GRID_NNLI",SWIG_From_int((int)(5)));
23638 SWIG_Python_SetConstant(d, "GRID_NNAIDW",SWIG_From_int((int)(6)));
23639 SWIG_Python_SetConstant(d, "PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
23640 SWIG_Python_SetConstant(d, "PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
23641 SWIG_Python_SetConstant(d, "PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
23642 SWIG_Python_SetConstant(d, "PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
23643 SWIG_Python_SetConstant(d, "PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
23644 SWIG_Python_SetConstant(d, "PL_POSITION_NULL",SWIG_From_int((int)(0x0)));
23645 SWIG_Python_SetConstant(d, "PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
23646 SWIG_Python_SetConstant(d, "PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
23647 SWIG_Python_SetConstant(d, "PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
23648 SWIG_Python_SetConstant(d, "PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
23649 SWIG_Python_SetConstant(d, "PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
23650 SWIG_Python_SetConstant(d, "PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
23651 SWIG_Python_SetConstant(d, "PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
23652 SWIG_Python_SetConstant(d, "PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
23653 SWIG_Python_SetConstant(d, "PL_LEGEND_NULL",SWIG_From_int((int)(0x0)));
23654 SWIG_Python_SetConstant(d, "PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
23655 SWIG_Python_SetConstant(d, "PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
23656 SWIG_Python_SetConstant(d, "PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
23657 SWIG_Python_SetConstant(d, "PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
23658 SWIG_Python_SetConstant(d, "PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
23659 SWIG_Python_SetConstant(d, "PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
23660 SWIG_Python_SetConstant(d, "PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
23661 SWIG_Python_SetConstant(d, "PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
23662 SWIG_Python_SetConstant(d, "PL_COLORBAR_NULL",SWIG_From_int((int)(0x0)));
23663 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
23664 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
23665 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
23666 SWIG_Python_SetConstant(d, "PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
23667 SWIG_Python_SetConstant(d, "PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
23668 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
23669 SWIG_Python_SetConstant(d, "PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
23670 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
23671 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
23672 SWIG_Python_SetConstant(d, "PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
23673 SWIG_Python_SetConstant(d, "PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
23674 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
23675 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
23676 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
23677 SWIG_Python_SetConstant(d, "PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
23678 SWIG_Python_SetConstant(d, "PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
23679 SWIG_Python_SetConstant(d, "PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
23680 SWIG_Python_SetConstant(d, "PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
23681 SWIG_Python_SetConstant(d, "PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
23682 SWIG_Python_SetConstant(d, "PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
23683 SWIG_Python_SetConstant(d, "PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
23684 SWIG_Python_SetConstant(d, "DRAW_LINEX",SWIG_From_int((int)(0x001)));
23685 SWIG_Python_SetConstant(d, "DRAW_LINEY",SWIG_From_int((int)(0x002)));
23686 SWIG_Python_SetConstant(d, "DRAW_LINEXY",SWIG_From_int((int)(0x003)));
23687 SWIG_Python_SetConstant(d, "MAG_COLOR",SWIG_From_int((int)(0x004)));
23688 SWIG_Python_SetConstant(d, "BASE_CONT",SWIG_From_int((int)(0x008)));
23689 SWIG_Python_SetConstant(d, "TOP_CONT",SWIG_From_int((int)(0x010)));
23690 SWIG_Python_SetConstant(d, "SURF_CONT",SWIG_From_int((int)(0x020)));
23691 SWIG_Python_SetConstant(d, "DRAW_SIDES",SWIG_From_int((int)(0x040)));
23692 SWIG_Python_SetConstant(d, "FACETED",SWIG_From_int((int)(0x080)));
23693 SWIG_Python_SetConstant(d, "MESH",SWIG_From_int((int)(0x100)));
23694#if PY_VERSION_HEX >= 0x03000000
23695 return m;
23696#else
23697 return;
23698#endif
23699}
23700
#define min(x, y)
Definition nnpi.c:87
#define max(x, y)
Definition nnpi.c:88
void plOptUsage(void)
Definition plargs.c:1304
void plClearOpts(void)
Definition plargs.c:830
void plResetOpts(void)
Definition plargs.c:843
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition plargs.c:1287
static int error
Definition plcont.c:61
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:941
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition plcont.c:874
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition plcont.c:858
void plsxwin(PLINT window_id)
Definition plcore.c:3978
static PLFLT value(double n1, double n2, double hue)
Definition plctrl.c:1219
void plMinMax2dGrid(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLFLT *fnmax, PLFLT *fnmin)
Definition plmem.c:141
PLINT plGetCursor(PLGraphicsIn *plg)
Definition plpage.c:244
#define plgfci
Definition plplot.h:735
#define plgstrm
Definition plplot.h:744
#define plpat
Definition plplot.h:779
#define plschr
Definition plplot.h:790
#define plfontld
Definition plplot.h:721
#define plpath
Definition plplot.h:761
#define plerry
Definition plplot.h:715
#define plsfam
Definition plplot.h:816
#define plsmaj
Definition plplot.h:826
#define plsmin
Definition plplot.h:829
#define pleop
Definition plplot.h:713
#define plimage
Definition plplot.h:753
#define plstransform
Definition plplot.h:840
#define plmap
Definition plplot.h:764
#define plfill
Definition plplot.h:717
#define plvpas
Definition plplot.h:859
#define plgdiplt
Definition plplot.h:732
#define plerrx
Definition plplot.h:714
#define plinit
Definition plplot.h:755
#define plscmap1l
Definition plplot.h:796
#define plsori
Definition plplot.h:830
#define plbox3
Definition plplot.h:698
#define plmapfill
Definition plplot.h:768
#define plcol1
Definition plplot.h:703
#define pltimefmt
Definition plplot.h:856
PLUINT PLUNICODE
Definition plplot.h:201
#define plmaptex
Definition plplot.h:767
#define plvect
Definition plplot.h:858
#define plgchr
Definition plplot.h:722
float PLFLT
Definition plplot.h:163
#define pllegend
Definition plplot.h:758
#define plsyax
Definition plplot.h:852
#define plgver
Definition plplot.h:745
#define plscolbg
Definition plplot.h:802
#define plpsty
Definition plplot.h:784
#define plgfont
Definition plplot.h:737
#define plenv
Definition plplot.h:711
#define pllightsource
Definition plplot.h:759
#define plsmema
Definition plplot.h:828
#define plpoin3
Definition plplot.h:781
#define plgspa
Definition plplot.h:743
#define plscol0
Definition plplot.h:800
#define plptex
Definition plplot.h:785
#define plrgbhls
Definition plplot.h:789
#define plbop
Definition plplot.h:696
#define plgdidev
Definition plplot.h:730
#define plpoin
Definition plplot.h:780
#define plptex3
Definition plplot.h:786
#define plstripd
Definition plplot.h:845
#define plhist
Definition plplot.h:751
#define plmapline
Definition plplot.h:765
#define plgfnam
Definition plplot.h:736
#define plgdiori
Definition plplot.h:731
#define plszax
Definition plplot.h:854
#define plsmem
Definition plplot.h:827
#define plstripa
Definition plplot.h:843
#define plgxax
Definition plplot.h:748
#define plgra
Definition plplot.h:740
#define plenv0
Definition plplot.h:712
#define plspal1
Definition plplot.h:833
#define plstring3
Definition plplot.h:842
#define plxormod
Definition plplot.h:865
#define plspause
Definition plplot.h:834
#define plgdev
Definition plplot.h:729
#define plgradient
Definition plplot.h:741
#define plspal0
Definition plplot.h:832
#define plcalc_world
Definition plplot.h:700
#define plwidth
Definition plplot.h:863
#define pllab
Definition plplot.h:757
#define plsurf3d
Definition plplot.h:847
#define plsurf3dl
Definition plplot.h:848
#define plvasp
Definition plplot.h:857
#define plscmap0n
Definition plplot.h:793
#define plmtex3
Definition plplot.h:774
#define plctime
Definition plplot.h:708
#define plclear
Definition plplot.h:701
#define plsvpa
Definition plplot.h:850
#define plw3d
Definition plplot.h:862
#define plot3dcl
Definition plplot.h:777
#define plscmap1n
Definition plplot.h:798
#define plgvpd
Definition plplot.h:746
#define plhlsrgb
Definition plplot.h:752
#define pl_setcontlabelformat
Definition plplot.h:690
#define plsdev
Definition plplot.h:806
#define plconfigtime
Definition plplot.h:705
#define plscolbga
Definition plplot.h:803
#define PL_UNUSED(x)
Definition plplot.h:138
#define plscmap1
Definition plplot.h:794
#define plsdiplz
Definition plplot.h:811
#define plparseopts
Definition plplot.h:778
#define plmapstring
Definition plplot.h:766
#define plot3d
Definition plplot.h:775
#define plsesc
Definition plplot.h:814
#define plarc
Definition plplot.h:693
#define plsetopt
Definition plplot.h:815
#define plgvpw
Definition plplot.h:747
#define pltext
Definition plplot.h:855
#define plstring
Definition plplot.h:841
#define plsdiori
Definition plplot.h:809
#define plcont
Definition plplot.h:706
#define plspage
Definition plplot.h:831
#define plaxes
Definition plplot.h:694
#define pllsty
Definition plplot.h:763
#define plslabelfunc
Definition plplot.h:825
#define plshades
Definition plplot.h:824
#define plglevel
Definition plplot.h:738
#define plscompression
Definition plplot.h:805
#define plfamadv
Definition plplot.h:716
#define plfont
Definition plplot.h:720
#define plscmap0a
Definition plplot.h:792
#define plgcol0a
Definition plplot.h:725
#define plscmap1_range
Definition plplot.h:799
#define plmeshc
Definition plplot.h:771
#define plshade
Definition plplot.h:820
#define plsym
Definition plplot.h:853
#define plscmap1a
Definition plplot.h:795
#define plscmap0
Definition plplot.h:791
#define plgriddata
Definition plplot.h:742
#define plstripc
Definition plplot.h:844
#define pl_setcontlabelparam
Definition plplot.h:691
#define plsvect
Definition plplot.h:849
#define plstyl
Definition plplot.h:846
#define plline
Definition plplot.h:760
#define pljoin
Definition plplot.h:756
#define plgzax
Definition plplot.h:750
#define plsstrm
Definition plplot.h:835
#define plscmap1la
Definition plplot.h:797
#define plssym
Definition plplot.h:837
#define plscolor
Definition plplot.h:804
#define plcol0
Definition plplot.h:702
#define plsdiplt
Definition plplot.h:810
#define plcolorbar
Definition plplot.h:704
#define plvsta
Definition plplot.h:861
#define plmeridians
Definition plplot.h:769
#define plot3dc
Definition plplot.h:776
#define plcpstrm
Definition plplot.h:707
#define plmkstrm
Definition plplot.h:772
#define plgcol0
Definition plplot.h:724
#define pladv
Definition plplot.h:692
#define plgcolbga
Definition plplot.h:727
#define plline3
Definition plplot.h:762
#define plprec
Definition plplot.h:783
#define plfill3
Definition plplot.h:718
#define plseed
Definition plplot.h:813
#define plgcompression
Definition plplot.h:728
#define plimagefr
Definition plplot.h:754
#define plsfont
Definition plplot.h:819
int PLINT
Definition plplot.h:181
#define plgfam
Definition plplot.h:734
#define plscol0a
Definition plplot.h:801
#define plend1
Definition plplot.h:710
#define plrandd
Definition plplot.h:787
#define plbin
Definition plplot.h:695
#define plsdidev
Definition plplot.h:807
#define plsfnam
Definition plplot.h:818
void * PLPointer
Definition plplot.h:209
#define plflush
Definition plplot.h:719
#define plwind
Definition plplot.h:864
#define plstar
Definition plplot.h:838
#define plmtex
Definition plplot.h:773
PLINT PLBOOL
Definition plplot.h:204
#define plsdimap
Definition plplot.h:808
#define plsfci
Definition plplot.h:817
#define plend
Definition plplot.h:709
#define plmesh
Definition plplot.h:770
#define plreplot
Definition plplot.h:788
#define plgcolbg
Definition plplot.h:726
#define plgcmap1_range
Definition plplot.h:723
#define plstart
Definition plplot.h:839
#define plsxax
Definition plplot.h:851
#define plbox
Definition plplot.h:697
#define plbtime
Definition plplot.h:699
#define plgyax
Definition plplot.h:749
#define plvpor
Definition plplot.h:860
#define plpoly3
Definition plplot.h:782
#define plgpage
Definition plplot.h:739
#define plssub
Definition plplot.h:836
SWIGINTERN PyObject * _wrap_plstransform(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *self, PyObject *args)
SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata))
SWIGINTERN PyObject * _wrap_plsxwin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_int(int value)
SWIGRUNTIME int SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *self, PyObject *args)
static swig_cast_info * swig_cast_initial[]
SWIGINTERN int swig_varlink_setattr(PyObject *o, char *n, PyObject *p)
SWIGINTERN PyObject * _wrap_plgra(PyObject *self, PyObject *args)
static int interpreter_counter
static PLcGrid2 tmpGrid2
SWIGINTERN PyObject * _wrap_plvpas(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *self, PyObject *args)
#define SWIG_MangledTypeQuery(name)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *self, PyObject *args)
static PLcGrid tmpGrid1
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *self, PyObject *args)
static PyObject * Swig_This_global
SWIGRUNTIME int SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
SWIGINTERN int SWIG_AsVal_double(PyObject *obj, double *val)
static swig_cast_info _swigc__p_PLcGrid2[]
SWIGINTERN PyObject * _wrap_plerrx(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *self, PyObject *args)
SWIGINTERN Py_ssize_t SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
#define SWIG_TypeQuery(name)
PLFLT do_f2eval_callback(PLINT x, PLINT y, PLPointer data)
#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)
#define SWIG_POINTER_OWN
SWIGINTERN PyObject * _wrap_plfill3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *self, PyObject *args)
#define SWIG_SyntaxError
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *self, PyObject *args)
#define SWIG_POINTER_NEW
SWIGINTERN PyObject * _wrap_plgfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *self, PyObject *args)
#define SWIG_CheckState(r)
static swig_cast_info _swigc__p_f_double_double__int[]
void cleanup_mapform(void)
void cleanup_PLPointer(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_int[]
SWIGINTERN PyObject * _wrap_plschr(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstart(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
#define SWIG_Py_XINCREF
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *self, PyObject *args)
#define SWIG_BUFFER_SIZE
#define SWIG_TypeError
SWIGRUNTIME int SWIG_Python_AddErrMesg(const char *mesg, int infront)
SWIGRUNTIME PyObject * SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
SWIGINTERN void SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[])
pltr_func marshal_pltr(PyObject *input)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *self, PyObject *args)
static PLINT Alen
#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
static swig_cast_info _swigc__p_double[]
#define SWIGTYPE_p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *self, PyObject *args)
void do_mapform_callback(PLINT n, PLFLT *x, PLFLT *y)
SWIGRUNTIME PyObject * SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plbin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *self, PyObject *args)
#define SWIG_PY_POINTER
struct swig_cast_info swig_cast_info
SWIGINTERN PyObject * _wrap_plpoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *self, PyObject *args)
#define SWIG_init
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
SWIGRUNTIME PyObject * SwigPyObject_hex(SwigPyObject *v)
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME void SwigPyObject_dealloc(PyObject *v)
SWIGRUNTIME PyTypeObject * SwigPyPacked_TypeOnce(void)
#define SWIG_PYTHON_THREAD_END_BLOCK
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *self, PyObject *args)
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *self, PyObject *args)
#define SWIG_RuntimeError
SWIGRUNTIME PyObject * SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
SWIGINTERN PyObject * _wrap_pladv(PyObject *self, PyObject *args)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
SWIGRUNTIME PyObject * SwigPyObject_append(PyObject *v, PyObject *next)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *self, PyObject *args)
#define SWIGPY_CAPSULE_ATTR_NAME
SWIGINTERN PyObject * _wrap_plsfont(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_newvarlink(void)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmema(PyObject *self, PyObject *args)
struct swig_varlinkobject swig_varlinkobject
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *self, PyObject *args)
#define SWIG_NewClientData(obj)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *self, PyObject *args)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *self, PyObject *args)
mapform_func marshal_mapform(PyObject *input)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGINTERN PyObject * _wrap_plline(PyObject *self, PyObject *args)
SWIGINTERNINLINE int SWIG_CanCastAsInteger(double *d, double min, double max)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *self, PyObject *args)
#define SWIGRUNTIME
SWIGINTERN PyObject * _wrap_plvasp(PyObject *self, PyObject *args)
#define SWIG_PY_BINARY
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *self, PyObject *args)
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *self, PyObject *args)
PyObject * python_f2eval
#define SWIG_RUNTIME_VERSION
SWIGINTERN PyObject * _wrap_plscolor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE const char * SwigPyObject_GetDesc(PyObject *self)
SWIGINTERN PyObject * _wrap_plssym(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_own(PyObject *v, PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *self, PyObject *args)
#define SWIG_POINTER_NOSHADOW
SWIGINTERN PyObject * _wrap_plwind(PyObject *self, PyObject *args)
#define SWIG_OLDOBJ
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
#define SWIG_ValueError
SWIGINTERN void SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int(*set_attr)(PyObject *p))
SWIGINTERN PyObject * _wrap_plend1(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SwigPyObject_acquire(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *self, PyObject *args)
static PyMethodDef swigobject_methods[]
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *self, PyObject *args)
#define SWIG_AddCast(r)
void cleanup_PLcGrid1(void)
SWIGRUNTIME PyObject * SWIG_Python_TypeCache(void)
#define SWIG_IsNewObj(r)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *self, PyObject *args)
#define SWIG_InternalNewPointerObj(ptr, type, flags)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *self, PyObject *args)
#define NPY_PLFLT
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_long(SwigPyObject *v)
#define SWIG_exception_fail(code, msg)
void cleanup_ct(void)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE PyObject * SWIG_Py_Void(void)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltr2(PyObject *self, PyObject *args)
void do_label_callback(PLINT axis, PLFLT value, char *string, PLINT len, PLPointer data)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *self, PyObject *args)
#define SWIG_AttributeError
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *self, PyObject *args)
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *self, PyObject *args)
static swig_module_info swig_module
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *self, PyObject *args)
static PLINT Ylen
SWIGINTERN PyObject * _wrap_pltr1(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_double
SWIGINTERN PyObject * _wrap_plgdev(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_TypeErrorOccurred(PyObject *obj)
SWIGRUNTIME void SWIG_Python_DestroyModule(PyObject *obj)
#define SWIG_SetModule(clientdata, pointer)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *self, PyObject *args)
SWIGRUNTIME SwigPyClientData * SwigPyClientData_New(PyObject *obj)
SWIGINTERN PyObject * swig_varlink_str(PyObject *o)
SWIGINTERN PyTypeObject * swig_varlink_type(void)
SWIGINTERN PyObject * _wrap_pllab(PyObject *self, PyObject *args)
#define SWIG_INIT_CLIENT_DATA_TYPE
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *self, PyObject *args)
#define SWIGUNUSEDPARM(p)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *self, PyObject *args)
PLPointer marshal_PLPointer(PyObject *input, int isimg)
#define SWIG_POINTER_RELEASE
SWIGINTERN PyObject * _wrap_plstring3(PyObject *self, PyObject *args)
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
#define SWIG_as_voidptr(a)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
static swig_const_info swig_const_table[]
SWIGINTERN PyObject * SwigPyObject_disown(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plscol0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SwigPyPacked_Check(PyObject *op)
static swig_type_info _swigt__p_p_char
#define SWIG_Python_CallFunctor(functor, obj)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
static swig_type_info _swigt__p_p_double
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *self, PyObject *args)
SWIGRUNTIME int SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
#define SWIG_POINTER_CLEAR
PyObject * python_label
#define SWIG_ConvertPtr(obj, pptr, type, flags)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
#define SWIGTYPE_p_int
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
struct swig_const_info swig_const_info
SWIGINTERN PyObject * _wrap_plpsty(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plimage(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *self, PyObject *args)
static PyObject * Swig_Globals_global
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *self, PyObject *args)
void *(* swig_converter_func)(void *, int *)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyPacked_repr(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_plsetopt(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *self, PyObject *args)
#define SWIG_newvarlink()
SWIGRUNTIME void SWIG_Python_RaiseOrModifyTypeError(const char *message)
SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type)
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
SWIGINTERN const char * SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_f_int_p_q_const__double_p_q_const__double__void
PLINT(* defined_func)(PLFLT, PLFLT)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *self, PyObject *args)
void cleanup_pltr(void)
void cleanup_PLcGrid2(void)
static PyObject * Swig_TypeCache_global
SWIGINTERN PyObject * _wrap_plglevel(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_p_double[]
#define SWIGINTERN
SWIGRUNTIMEINLINE PyObject * SWIG_Python_ExceptionType(swig_type_info *desc)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *op)
SWIGINTERN PyObject * _wrap_plpath(PyObject *self, PyObject *args)
#define SWIG_From_double
SWIGINTERN void SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj)
SWIGINTERN int SWIG_AsVal_char(PyObject *obj, char *val)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *self, PyObject *args)
#define SWIG_Py_INCREF
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
struct swig_globalvar swig_globalvar
PyArrayObject * myIntArray_ContiguousFromObject(PyObject *in, int type, int mindims, int maxdims)
#define SWIGPY_CAPSULE_NAME
SWIGRUNTIME void * SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags)
#define SWIG_ArgError(r)
SWIGRUNTIME void SWIG_Python_AddErrorMsg(const char *mesg)
PyObject * python_pltr
SWIGINTERNINLINE PyObject * SWIG_FromCharPtrAndSize(const char *carray, size_t size)
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
#define SWIG_NewPointerObj(ptr, type, flags)
SWIGRUNTIME void SWIG_Python_SetModule(swig_module_info *swig_module)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *self, PyObject *args)
ct_func marshal_ct(PyObject *input)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN void SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *self, PyObject *args)
#define SWIG_POINTER_NO_NULL
#define SWIG_Python_str_FromFormat
#define SWIG_InstallConstants(d, constants)
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *self, PyObject *args)
#define SWIG_IOError
static PyMethodDef SwigMethods[]
SWIGINTERN PyObject * SWIG_Python_AppendOutput(PyObject *result, PyObject *obj, int is_void)
#define SWIG_NullReferenceError
SWIGRUNTIME PyTypeObject * SwigPyPacked_type(void)
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
SWIGINTERN PyObject * _wrap_pleop(PyObject *self, PyObject *args)
SWIGINTERNINLINE PyObject * SWIG_From_unsigned_SS_int(unsigned int value)
void do_ct_callback(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
#define SWIG_POINTER_DISOWN
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *self, PyObject *args)
#define SWIG_STATIC_POINTER(var)
struct swig_type_info swig_type_info
PyObject * python_mapform
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_repr(PyObject *SWIGUNUSEDPARM(v))
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
static swig_type_info _swigt__p_PLGraphicsIn
SWIGINTERN PyObject * _wrap_plflush(PyObject *self, PyObject *args)
#define SWIG_IsTmpObj(r)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_f_double_double__int
SWIGINTERN PyObject * _wrap_plcont(PyObject *self, PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
SWIGRUNTIME int SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty)
SWIGINTERN void SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg)
SWIGINTERN PyObject * _wrap_plsori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_format(const char *fmt, SwigPyObject *v)
SWIGINTERN PyObject * _wrap_plbop(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags)
#define SWIG_NEWOBJ
#define MY_BLOCK_THREADS
SWIGINTERN PyObject * _wrap_plgver(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *self, PyObject *args)
#define SWIG_TMPOBJ
SWIGINTERN PyObject * _wrap_pllsty(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ArgFail(int argnum)
#define SWIG_DelNewMask(r)
SWIGRUNTIME swig_type_info * SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *self, PyObject *args)
#define SWIG_NewPackedObj(ptr, sz, type)
static swig_cast_info _swigc__p_PLcGrid[]
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *self, PyObject *args)
PLcGrid * marshal_PLcGrid1(PyObject *input, int isimg)
#define SWIG_GetModule(clientdata)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_unsigned_int[]
#define SWIG_fail
static swig_type_info _swigt__p_int
SWIGINTERN PyObject * PLGraphicsIn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *self, PyObject *args)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty)
SWIGRUNTIME void SWIG_PropagateClientData(void)
PyArrayObject * pltr_xg
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
#define NPY_PLINT
SWIGRUNTIME PyObject * SwigPyPacked_str(SwigPyPacked *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
SWIGINTERN PyObject * _wrap_plsmem(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *self, PyObject *args)
SWIGINTERN void SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial)
SWIGRUNTIMEINLINE PyObject * SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
#define SWIG_ERROR_RELEASE_NOT_OWNED
SWIGRUNTIME PyObject * SWIG_This(void)
SWIGINTERN PyObject * _wrap_plenv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *self, PyObject *args)
SWIGRUNTIME void SWIG_Python_TypeError(const char *type, PyObject *obj)
SWIGINTERN int SWIG_AsVal_int(PyObject *obj, int *val)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *self, PyObject *args)
static swig_type_info _swigt__p_PLcGrid
#define SWIG_BUILTIN_TP_INIT
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
SWIGINTERN void swig_varlink_dealloc(PyObject *o)
SWIGRUNTIME PyObject * SwigPyObject_repr(SwigPyObject *v)
static PLINT Xlen
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
SWIGINTERN PyObject * _wrap_plfont(PyObject *self, PyObject *args)
SWIGINTERN int SWIG_AsVal_long(PyObject *obj, long *val)
SWIGINTERN int SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *self, PyObject *args)
PyArrayObject * pltr_yg
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *self, PyObject *args)
struct swig_module_info swig_module_info
PyObject * python_ct
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SWIG_Python_ErrorType(int code)
#define SWIG_ERROR
SWIGRUNTIME void SwigPyClientData_Del(SwigPyClientData *data)
#define SWIG_name
SWIGRUNTIME SwigPyObject * SWIG_Python_GetSwigThis(PyObject *pyobj)
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
void do_pltr_callback(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer data)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *self, PyObject *args)
static swig_type_info * swig_type_initial[]
SWIGINTERN PyObject * _wrap_plerry(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *self, PyObject *args)
SWIGRUNTIME void SwigPyPacked_dealloc(PyObject *v)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *self, PyObject *args)
SWIGINTERN PyObject * SWIG_Python_str_FromChar(const char *c)
#define PySequence_Fast_GET_ITEM
SWIGINTERN PyObject * _wrap_plmap(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
SWIGINTERN PyObject * _wrap_plhist(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGINTERN PyObject * _wrap_pltr0(PyObject *self, PyObject *args)
SWIGRUNTIMEINLINE int SWIG_Python_CheckImplicit(swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *self, PyObject *args)
PLcGrid2 * marshal_PLcGrid2(PyObject *input, int isimg)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *self, PyObject *args)
SWIGINTERN PyObject * swig_varlink_getattr(PyObject *o, char *n)
static swig_cast_info _swigc__p_p_char[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *self, PyObject *args)
#define PySequence_Size
SWIGINTERN PyObject * _wrap_plMinMax2dGrid(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *self, PyObject *args)
#define SWIG_MemoryError
SWIGINTERN PyObject * _wrap_plfontld(PyObject *self, PyObject *args)
#define SWIG_SystemError
#define SWIG_DivisionByZero
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *self, PyObject *args)
#define SWIGTYPE_p_double
static swig_type_info _swigt__p_char
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_type(void)
#define SWIG_OverflowError
#define SWIGEXPORT
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *self, PyObject *args)
SWIGRUNTIME PyTypeObject * SwigPyObject_TypeOnce(void)
#define SWIG_IsOK(r)
SWIGINTERN PyObject * _wrap_plstring(PyObject *self, PyObject *args)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
SWIGINTERN int SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
static PyObject * Swig_Capsule_global
static swig_type_info _swigt__p_PLcGrid2
SWIGINTERN PyObject * _wrap_plctime(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *self, PyObject *args)
#define SWIG_IndexError
SWIGINTERN PyObject * _wrap_plspal0(PyObject *self, PyObject *args)
SWIGRUNTIME PyObject * SwigPyObject_oct(SwigPyObject *v)
static swig_type_info * swig_types[15]
SWIGRUNTIME PyObject * SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *self, PyObject *args)
static swig_cast_info _swigc__p_f_int_p_q_const__double_p_q_const__double__void[]
SWIGINTERN PyObject * PLGraphicsIn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * SWIG_Python_InitShadowInstance(PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *self, PyObject *args)
#define SWIG_AddNewMask(r)
SWIGINTERN PyObject * SWIG_globals(void)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *self, PyObject *args)
#define SWIG_OK
SWIGINTERN PyObject * _wrap_plbox(PyObject *self, PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *self, PyObject *args)
#define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#define SWIGINTERNINLINE
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *self, PyObject *args)
enum callback_type pltr_type
SWIGINTERN PyObject * _wrap_plaxes(PyObject *self, PyObject *args)
SWIGRUNTIME int SWIG_Python_AcquirePtr(PyObject *obj, int own)
#define MY_UNBLOCK_THREADS
#define SWIGRUNTIMEINLINE
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
char string[PL_MAXKEY]
Definition plplot.h:440
PLINT nx
Definition plplot.h:521
PLFLT_NC_MATRIX xg
Definition plplot.h:520
PLINT ny
Definition plplot.h:521
PLFLT_NC_MATRIX yg
Definition plplot.h:520
PLFLT_NC_FE_POINTER xg
Definition plplot.h:508
PLFLT_NC_FE_POINTER yg
Definition plplot.h:508
PLINT nx
Definition plplot.h:509
PLINT ny
Definition plplot.h:509
PyObject_HEAD void * ptr
swig_type_info * ty
swig_type_info * ty
PyObject_HEAD void * pack
swig_type_info * type
struct swig_cast_info * prev
struct swig_cast_info * next
swig_converter_func converter
swig_type_info ** ptype
PyObject *(* get_attr)(void)
struct swig_globalvar * next
int(* set_attr)(PyObject *)
swig_type_info ** types
swig_cast_info ** cast_initial
swig_type_info ** type_initial
struct swig_module_info * next
swig_dycast_func dcast
struct swig_cast_info * cast
PyObject_HEAD swig_globalvar * vars
static char buf[200]
Definition tclAPI.c:873
static tclMatrixXtnsnDescr * tail
Definition tclMatrix.c:461
static const char * name
Definition tkMain.c:135